/++
This module was automatically generated from the following grammar:


    ES6:
        Module                  < ModuleBody eoi
        ModuleBody              < ModuleItemList
        ModuleItemList          < (ImportDeclaration / ExportDeclaration / StatementListItem)+
        ImportDeclaration       < "import" ((ImportClause FromClause) / ModuleSpecifier) ";"
        ImportClause            < NameSpaceImport / NamedImports / (ImportedDefaultBinding "," NameSpaceImport) / (ImportedDefaultBinding "," NamedImports) / ImportedDefaultBinding
        ImportedDefaultBinding  < ImportedBinding
        NameSpaceImport         < "*" "as" ImportedBinding
        NamedImports            < CurlyBrackets((ImportsList (",")?)?)
        FromClause              < "from" ModuleSpecifier
        ImportsList             < ImportSpecifier ("," ImportSpecifier)*
        ImportSpecifier         < (IdentifierName "as" ImportedBinding) / ImportedBinding
        ModuleSpecifier         < StringLiteral
        ImportedBinding         < BindingIdentifier
        ExportDeclaration       <   / ("export" "*" FromClause ";")
                                    / ("export" ExportClause FromClause ";")
                                    / ("export" ExportClause ";")
                                    / ("export" "default" HoistableDeclarationDefault)
                                    / ("export" "default" ClassDeclarationDefault)
                                    / ("export" "default" !("function" / "class") AssignmentExpressionIn ";")
                                    / ("export" VariableStatement)
                                    / ("export" Declaration)

        ExportClause                        < CurlyBrackets((ExportsList (",")?)?)
        ExportsList                         < ExportSpecifier ("," ExportSpecifier)*
        ExportSpecifier                     < IdentifierName ("as" IdentifierName)?
        SourceCharacter                     <- [\u0000-\uFFFC]
        InputElementDiv                     <- WhiteSpace / LineTerminator / Comment / CommonToken / DivPunctuator / RightBracePunctuator
        InputElementRegExp                  <- WhiteSpace / LineTerminator / Comment / CommonToken / RightBracePunctuator / RegularExpressionLiteral
        InputElementRegExpOrTemplateTail    <- WhiteSpace / LineTerminator / Comment / CommonToken / RegularExpressionLiteral / TemplateSubstitutionTail
        InputElementTemplateTail            <- WhiteSpace / LineTerminator / Comment / CommonToken / DivPunctuator / TemplateSubstitutionTail

        WhiteSpace                      <- "\u0009" / "\u000B" / "\u000C" / "\u0020" / "\u00A0" / "\uFEFF" / [\u02B0-\u02FF]
        LineTerminator                  <- "\u000A" / "\u000D" / "\u2028" / "\u2029"
        LineTerminatorSequence          <- "\u000A" / ("\u000D" !"\u000A") / "\u2028" / "\u2029" / ("\u000D\u000A")
        Spacing                         <~ (:WhiteSpace / :LineTerminatorSequence / Comment)*
        Spaces                          <~ (:WhiteSpace / Comment)*

        Comment                         <~ MultiLineComment / SingleLineComment
        MultiLineComment                <~ :"/*" (!"*/" SourceCharacter)* :"*/"
        SingleLineComment               <- :"//" SingleLineCommentChars? eol
        SingleLineCommentChars          <- SingleLineCommentChar+
        SingleLineCommentChar           <- !LineTerminator SourceCharacter

        CommonToken                     <- IdentifierName / Punctuator / NumericLiteral / StringLiteral / Template
        IdentifierName                  <~ IdentifierStart IdentifierPart*
        IdentifierStart                 <~ UnicodeIDStart / "$" / "_" / ("\\" UnicodeEscapeSequence)
        IdentifierPart                  <~ UnicodeIDContinue / "$" / "_" / ("\\" UnicodeEscapeSequence) / "\u200C" / "\u200D"
        UnicodeIDStart                  <~ ID_Start / Other_ID_Start

        ID_Start                        <- [\u0041-\u005a] / [\u0061-\u007a] / "\u00aa" / "\u00b5" / "\u00ba" / [\u00c0-\u00d6] / [\u00d8-\u00f6]
        Other_ID_Start                  <- "\u2118" / "\u212e" / [\u309b-\u309c]
        UnicodeIDContinue               <- ID_Continue / Other_ID_Continue / Other_ID_Start
        ID_Continue                     <- [\u0030-\u0039] / [\u0041-\u005a] / "\u005f" / [\u0061-\u007a] / "\u00aa" / "\u00b5" / "\u00b7" / "\u00ba" / [\u00c0-\u00d6] / [\u00d8-\u00f6]
        Other_ID_Continue               <- "\u00b7" / "\u0387" / [\u1369-\u1371] / "\u19da"

        ReservedWord                    <- Keyword / FutureReservedWord / NullLiteral / BooleanLiteral
        Keyword                         <- "break" / "do" / "in" / "typeof" / "case" / "else" / "instanceof" / "var" / "catch" / "export" / "new" / "void" / "class" / "extends" / "return" / "while" / "const" / "finally" / "super" / "with" / "continue" / "for" / "switch" / "yield" / "debugger" / "function" / "this" / "default" / "if" / "throw" / "delete" / "import" / "try"
        FutureReservedWord              <- "enum" / "await"
        Punctuator                      <- "{" / "}" / "(" / ")" / "[" / "]" / "." / ";" / "," / "<=" / ">=" / "<" / ">" / "===" / "!==" / "==" / "!=" / "++" / "--" / "*=" / "*" / "%=" / "%" / "+=" / "+" / "-=" / "-" / "<<=" / "<<" / ">>>=" / ">>>" / ">>=" / ">>" / "&&" / "||" / "^=" / "^" / "!" / "~" / "&=" / "&" / "|=" / "|" / "?" / ":" / "=>" / "="
        DivPunctuator                   <- "/=" / "/"
        RightBracePunctuator            <- "}"
        NullLiteral                     <- "null"
        BooleanLiteral                  <- "true" / "false"
        NumericLiteral                  <- HexIntegerLiteral / DecimalLiteral / BinaryIntegerLiteral / OctalIntegerLiteral
        DecimalLiteral                  <~ (DecimalIntegerLiteral ("." DecimalDigits?)? ExponentPart?) / ("." DecimalDigits ExponentPart?)
        DecimalIntegerLiteral           <- "0" / (NonZeroDigit DecimalDigits?)
        DecimalDigits                   <~ DecimalDigit+
        DecimalDigit                    <- [0-9]
        NonZeroDigit                    <- [1-9]
        ExponentPart                    <- ExponentIndicator SignedInteger
        ExponentIndicator               <- "e" / "E"
        SignedInteger                   <- ("+" / "-")? DecimalDigits
        BinaryIntegerLiteral            <~ ("0b" / "0B") BinaryDigits
        BinaryDigits                    <~ BinaryDigit+
        BinaryDigit                     <- "0" / "1"
        OctalIntegerLiteral             <~ ("0o" / "0O") OctalDigits
        OctalDigits                     <- OctalDigit+
        OctalDigit                      <- [0-7]
        HexIntegerLiteral               <~ ("0x" / "0X") HexDigits
        HexDigits                       <- HexDigit+
        HexDigit                        <- [0-9a-fA-F]

        StringLiteral                   <~ ("\"" DoubleStringCharacters? "\"") / ("'" SingleStringCharacters? "'")
        DoubleStringCharacters          <- DoubleStringCharacter+
        SingleStringCharacters          <- SingleStringCharacter+
        DoubleStringCharacter           <- (!("\"" / "\\" / LineTerminator) SourceCharacter) / ("\\" EscapeSequence) / LineContinuation
        SingleStringCharacter           <- (!("\'" / "\\" / LineTerminator) SourceCharacter) / ("\\" EscapeSequence) / LineContinuation
        LineContinuation                <- "\\" LineTerminatorSequence
        EscapeSequence                  <- (CharacterEscapeSequence / ("0" !DecimalDigit)) / HexEscapeSequence / UnicodeEscapeSequence
        CharacterEscapeSequence         <- SingleEscapeCharacter / NonEscapeCharacter
        SingleEscapeCharacter           <- "'" / "\"" / "\\" / "b" / "f" / "n" / "r" / "t" / "v"
        NonEscapeCharacter              <- !(EscapeCharacter / LineTerminator) SourceCharacter
        EscapeCharacter                 <- SingleEscapeCharacter / DecimalDigit / "x" / "u"
        HexEscapeSequence               <- "x" HexDigit HexDigit
        UnicodeEscapeSequence           <- ("u" Hex4Digits) / "u{" HexDigits "}"
        Hex4Digits                      <- HexDigit HexDigit HexDigit HexDigit

        RegularExpressionLiteral        <- "/" RegularExpressionBody "/" RegularExpressionFlags
        RegularExpressionBody           <- RegularExpressionFirstChar RegularExpressionChars
        RegularExpressionChars          <- RegularExpressionChar*

        RegularExpressionFirstChar          <- (!("*" / "\\" / "/" / "[") RegularExpressionNonTerminator) / RegularExpressionBackslashSequence / RegularExpressionClass
        RegularExpressionChar               <- (!("\\" / "/" / "[") RegularExpressionNonTerminator) / RegularExpressionBackslashSequence / RegularExpressionClass
        RegularExpressionBackslashSequence  <- "\\" RegularExpressionNonTerminator
        RegularExpressionNonTerminator      <- !LineTerminator SourceCharacter
        RegularExpressionClass              <- :"[" RegularExpressionClassChars :"]"
        RegularExpressionClassChars         <- RegularExpressionClassChar*
        RegularExpressionClassChar          <- (!("]" / "\\") RegularExpressionNonTerminator) / RegularExpressionBackslashSequence
        RegularExpressionFlags              <- IdentifierPart*

        Template                            <- NoSubstitutionTemplate / TemplateHead
        NoSubstitutionTemplate              <- :"\u0060" TemplateCharacters? :"\u0060"
        TemplateHead                        <- :"\u0060" TemplateCharacters? :"${"
        TemplateSubstitutionTail            <- TemplateMiddle / TemplateTail
        TemplateMiddle                      <- :"}" TemplateCharacters? :"${"
        TemplateTail                        <- :"}" TemplateCharacters? :"\u0060"
        TemplateCharacters                  <- TemplateCharacter+
        TemplateCharacter                   <- ("$" !"{") / ("\\" EscapeSequence) / LineContinuation / LineTerminatorSequence / (!("\u0060" / "\\" / "$" / LineTerminator) SourceCharacter)

        IdentifierReference                 < Identifier / "yield"
        IdentifierReferenceYield            < Identifier
        BindingIdentifier                   < Identifier / "yield"
        BindingIdentifierYield              < Identifier
        LabelIdentifier                     < Identifier / "yield"
        LabelIdentifierYield                < Identifier
        Identifier                          <- !(ReservedWord (WhiteSpace / LineTerminatorSequence / Comment / ";" / ":")) IdentifierName
        ThisKeyword                         <- ("this" !IdentifierPart)

        PrimaryExpression                                       < ThisKeyword / Literal / ArrayLiteral / ObjectLiteral / GeneratorExpression / ClassExpression / FunctionExpression / RegularExpressionLiteral / TemplateLiteral / CoverParenthesizedExpressionAndArrowParameterList / IdentifierReference
        PrimaryExpressionYield                                  < ThisKeyword / Literal / ArrayLiteralYield / ObjectLiteralYield / GeneratorExpression / ClassExpressionYield / FunctionExpression / RegularExpressionLiteral / TemplateLiteralYield / CoverParenthesizedExpressionAndArrowParameterListYield / IdentifierReferenceYield
        CoverParenthesizedExpressionAndArrowParameterList       < Parentheses(ExpressionIn "," "..." BindingIdentifier) / Parentheses("..." BindingIdentifier) / Parentheses(ExpressionIn?)
        CoverParenthesizedExpressionAndArrowParameterListYield  < Parentheses(ExpressionInYield "," "..." BindingIdentifierYield) / Parentheses("..." BindingIdentifierYield) / Parentheses(ExpressionInYield?)

        ParenthesizedExpression         < Parentheses(ExpressionIn)
        ParenthesizedExpressionYield    < Parentheses(ExpressionInYield)
        Literal                         <- ((NullLiteral / BooleanLiteral / NumericLiteral) !(IdentifierStart / IdentifierPart)) / StringLiteral
        ArrayLiteral                    < SquareBrackets(ElementList? Elision?)
        ArrayLiteralYield               < SquareBrackets(ElementListYield? Elision?)
        ElementList                     < Elision? (AssignmentExpressionIn / SpreadElement) (:"," Elision? (AssignmentExpressionIn / SpreadElement))*
        ElementListYield                < Elision? (AssignmentExpressionInYield / SpreadElementYield) (:"," Elision? (AssignmentExpressionInYield / SpreadElementYield))*
        Elision                         < ","+
        SpreadElement                   < :"..." AssignmentExpressionIn
        SpreadElementYield              < :"..." AssignmentExpressionInYield
        ObjectLiteral                   < CurlyBrackets((PropertyDefinitionList :","?)?)
        ObjectLiteralYield              < CurlyBrackets((PropertyDefinitionListYield :","?)?)
        PropertyDefinitionList          < PropertyDefinition ("," PropertyDefinition)*
        PropertyDefinitionListYield     < PropertyDefinitionYield ("," PropertyDefinitionYield)*
        PropertyDefinition              < MethodDefinition / CoverInitializedName / (PropertyName ":" AssignmentExpressionIn) / IdentifierReference
        PropertyDefinitionYield         < MethodDefinitionYield / CoverInitializedNameYield / (PropertyNameYield ":" AssignmentExpressionInYield) / IdentifierReferenceYield
        PropertyName                    < ComputedPropertyName / LiteralPropertyName
        PropertyNameYield               < ComputedPropertyNameYield / LiteralPropertyName
        LiteralPropertyName             < NumericLiteral / StringLiteral / IdentifierName
        ComputedPropertyName            < SquareBrackets(AssignmentExpressionIn)
        ComputedPropertyNameYield       < SquareBrackets(AssignmentExpressionInYield)
        CoverInitializedName            < IdentifierReference InitializerIn
        CoverInitializedNameYield       < IdentifierReferenceYield InitializerInYield
        Initializer                     < :"=" AssignmentExpression
        InitializerIn                   < :"=" AssignmentExpressionIn
        InitializerYield                < :"=" AssignmentExpressionYield
        InitializerInYield              < :"=" AssignmentExpressionInYield
        TemplateLiteral                 < NoSubstitutionTemplate / (TemplateHead ExpressionIn TemplateSpans)
        TemplateLiteralYield            < NoSubstitutionTemplate / (TemplateHead ExpressionInYield TemplateSpansYield)
        TemplateSpans                   < TemplateMiddleList? TemplateTail
        TemplateSpansYield              < TemplateMiddleListYield? TemplateTail
        TemplateMiddleList              < TemplateMiddleList? TemplateMiddle ExpressionIn
        TemplateMiddleListYield         < TemplateMiddleListYield? TemplateMiddle ExpressionInYield
        FieldAccessor                   < "." IdentifierName
        MemberExpression                < ((SuperProperty / MetaProperty / PrimaryExpression) / (NewKeyword ((SuperProperty / MetaProperty / PrimaryExpression) (SquareBrackets(ExpressionIn) / (FieldAccessor) / TemplateLiteral)*) Arguments)) (SquareBrackets(ExpressionIn) / (FieldAccessor) / TemplateLiteral)*
        MemberExpressionYield           < ((SuperPropertyYield / MetaProperty / PrimaryExpressionYield) / (NewKeyword ((SuperPropertyYield / MetaProperty / PrimaryExpressionYield) (SquareBrackets(ExpressionInYield) / (FieldAccessor) / TemplateLiteralYield)*) ArgumentsYield)) (SquareBrackets(ExpressionInYield) / (FieldAccessor) / TemplateLiteralYield)*
        SuperProperty                   < (:"super" SquareBrackets(ExpressionIn)) / (:"super" FieldAccessor)
        SuperPropertyYield              < (:"super" SquareBrackets(ExpressionInYield)) / (:"super" FieldAccessor)
        MetaProperty                    < NewTarget
        NewKeyword						<- "new" !(IdentifierStart / IdentifierPart)
        NewTarget                       < :"new" "." :"target"
        NewExpression                   < MemberExpression / ((NewKeyword WhiteSpace?)* MemberExpression)
        NewExpressionYield              < MemberExpressionYield / ((NewKeyword WhiteSpace?)* MemberExpressionYield)
        CallExpression                  < (SuperCall / (MemberExpression Arguments)) (SquareBrackets(ExpressionIn) / (FieldAccessor) / TemplateLiteral / Arguments)*
        CallExpressionYield             < (SuperCallYield / (MemberExpressionYield ArgumentsYield)) (SquareBrackets(ExpressionInYield) / (FieldAccessor) / TemplateLiteralYield / ArgumentsYield)*
        SuperCall                       < :"super" Arguments
        SuperCallYield                  < :"super" ArgumentsYield
        Arguments                       < Parentheses(ArgumentList?)
        ArgumentsYield                  < Parentheses(ArgumentListYield?)
        ArgumentList                    < "..."? AssignmentExpressionIn ("," ArgumentList)*
        ArgumentListYield               < "..."? AssignmentExpressionInYield ("," ArgumentListYield)*
        LeftHandSideExpression          < CallExpression / NewExpression
        LeftHandSideExpressionYield     < CallExpressionYield / NewExpressionYield
        PostfixExpression               < LeftHandSideExpression (Spaces (PostfixOperator))?
        PostfixExpressionYield          < LeftHandSideExpressionYield (Spaces (PostfixOperator))?
        PostfixOperator                 < "++" / "--"
        PrefixExpression                <- ((("delete" / "void" / "typeof") !(IdentifierStart / IdentifierPart)) / "++" / "--" / "+" / "-" / "~" / "!")
        UnaryExpression                 < PrefixExpression* PostfixExpression
        UnaryExpressionYield            < PrefixExpression* PostfixExpressionYield
        RightHandSideExpression         < BinaryExpression / UnaryExpression
        RightHandSideExpressionIn       < BinaryExpressionIn / UnaryExpression
        RightHandSideExpressionYield    < BinaryExpressionYield / UnaryExpressionYield
        RightHandSideExpressionInYield  < BinaryExpressionInYield / UnaryExpressionYield
        BinaryExpression                < UnaryExpression (ExpressionOperator UnaryExpression)+
        BinaryExpressionIn              < UnaryExpression (ExpressionOperatorIn UnaryExpression)+
        BinaryExpressionYield           < UnaryExpressionYield (ExpressionOperator UnaryExpressionYield)+
        BinaryExpressionInYield         < UnaryExpressionYield (ExpressionOperatorIn UnaryExpressionYield)+
        ExpressionOperator              < LogicalOperator / BitwiseOperator / EqualityOperator / ShiftOperator / RelationalOperator / AdditiveOperator / MultiplicativeOperator
        ExpressionOperatorIn            < LogicalOperator / BitwiseOperator / EqualityOperator / ShiftOperator / RelationalOperatorIn / AdditiveOperator / MultiplicativeOperator
        LogicalOperator                 < "||" / "&&"
        BitwiseOperator                 < "|" / "^" / "&"
        EqualityOperator                < "===" / "!==" / "==" / "!="
        RelationalOperator              < "<=" / ">=" / "<" / ">" / "instanceof"
        RelationalOperatorIn            < "<=" / ">=" / "<" / ">" / "instanceof" / "in"
        ShiftOperator                   < "<<" / ">>>" / ">>"
        AdditiveOperator                <- "+" / "-"
        MultiplicativeOperator          < "*" / "/" / "%"
        ConditionalExpression           < RightHandSideExpression ("?" AssignmentExpressionIn ":" AssignmentExpression)?
        ConditionalExpressionIn         < RightHandSideExpressionIn ("?" AssignmentExpressionIn ":" AssignmentExpressionIn)?
        ConditionalExpressionYield      < RightHandSideExpressionYield ("?" AssignmentExpressionInYield ":" AssignmentExpressionYield)?
        ConditionalExpressionInYield    < RightHandSideExpressionInYield ("?" AssignmentExpressionInYield ":" AssignmentExpressionInYield)?
        AssignmentExpression            < ((JSXElement / ArrowFunction / ConditionalExpression) !AssignmentOperator) / ((LeftHandSideExpression AssignmentOperator)* (JSXElement / ArrowFunction / ConditionalExpression))
        AssignmentExpressionIn          < ((JSXElement / ArrowFunctionIn / ConditionalExpressionIn) !AssignmentOperator) / ((LeftHandSideExpression AssignmentOperator)* (JSXElement / ArrowFunctionIn / ConditionalExpressionIn))
        AssignmentExpressionYield       < (YieldExpression / ArrowFunctionYield / ConditionalExpressionYield) / ((LeftHandSideExpressionYield AssignmentOperator)* (YieldExpression / ArrowFunctionYield / ConditionalExpressionYield))
        AssignmentExpressionInYield     < (YieldExpressionIn / ArrowFunctionInYield / ConditionalExpressionInYield) / ((LeftHandSideExpressionYield AssignmentOperator)* (YieldExpressionIn / ArrowFunctionInYield / ConditionalExpressionInYield))
        AssignmentOperator              < (!"==" "=") / "*=" / "/=" / "%=" / "+=" / "-=" / "<<=" / ">>=" / ">>>=" / "&=" / "^=" / "|="
        Comma                           < ","
        Expression                      < AssignmentExpression (Comma AssignmentExpression)*
        ExpressionIn                    < AssignmentExpressionIn (Comma AssignmentExpressionIn)*
        ExpressionYield                 < AssignmentExpressionYield (Comma AssignmentExpressionYield)*
        ExpressionInYield               < AssignmentExpressionInYield (Comma AssignmentExpressionInYield)*

        Statement                       < (BlockStatement / VariableStatement / EmptyStatement / IfStatement / BreakableStatement / ContinueStatement / BreakStatement / WithStatement / LabelledStatement / ThrowStatement / TryStatement / DebuggerStatement / ExpressionStatement) :";"?
        StatementYield                  < (BlockStatementYield / VariableStatementYield / EmptyStatement / IfStatementYield / BreakableStatementYield / ContinueStatementYield / BreakStatementYield / WithStatementYield / LabelledStatementYield / ThrowStatementYield / TryStatementYield / DebuggerStatement / ExpressionStatementYield) :";"?
        StatementReturn                 < (BlockStatementReturn / VariableStatement / EmptyStatement / IfStatementReturn / BreakableStatementReturn / ContinueStatement / BreakStatement / ReturnStatement / WithStatementReturn / LabelledStatementReturn / ThrowStatement / TryStatementReturn / DebuggerStatement / ExpressionStatement) :";"?
        StatementYieldReturn            < (BlockStatementYieldReturn / VariableStatementYield / EmptyStatement / IfStatementYieldReturn / BreakableStatementYieldReturn / ContinueStatementYield / BreakStatementYield / ReturnStatementYield / WithStatementYieldReturn / LabelledStatementYieldReturn / ThrowStatementYield / TryStatementYieldReturn / DebuggerStatement / ExpressionStatementYield) :";"?

        Declaration                         < HoistableDeclaration / ClassDeclaration / LexicalDeclarationIn
        DeclarationYield                    < HoistableDeclarationYield / ClassDeclarationYield / LexicalDeclarationInYield
        HoistableDeclaration                < GeneratorDeclaration / FunctionDeclaration
        HoistableDeclarationYield           < GeneratorDeclarationYield / FunctionDeclarationYield
        HoistableDeclarationDefault         < GeneratorDeclarationDefault / FunctionDeclarationDefault
        HoistableDeclarationYieldDefault    < GeneratorDeclarationYieldDefault / FunctionDeclarationYieldDefault

        BreakableStatement                  < IterationStatement / SwitchStatement
        BreakableStatementYield             < IterationStatementYield / SwitchStatementYield
        BreakableStatementReturn            < IterationStatementReturn / SwitchStatementReturn
        BreakableStatementYieldReturn       < IterationStatementYieldReturn / SwitchStatementYieldReturn

        BlockStatement                      < %Block
        BlockStatementYield                 < %BlockYield
        BlockStatementReturn                < %BlockReturn
        BlockStatementYieldReturn           < %BlockYieldReturn

        Block                               < CurlyBrackets(StatementList)
        BlockYield                          < CurlyBrackets(StatementListYield)
        BlockReturn                         < CurlyBrackets(StatementListReturn)
        BlockYieldReturn                    < CurlyBrackets(StatementListYieldReturn)

        StatementList                       < StatementListItem*
        StatementListYield                  < StatementListItemYield*
        StatementListReturn                 < StatementListItemReturn*
        StatementListYieldReturn            < StatementListItemYieldReturn*

        StatementListItem                   < Declaration / Statement
        StatementListItemYield              < DeclarationYield / StatementYield
        StatementListItemReturn             < Declaration / StatementReturn
        StatementListItemYieldReturn        < DeclarationYield / StatementYieldReturn

        LexicalDeclaration                  < LetOrConst BindingList :";"
        LexicalDeclarationIn                < LetOrConst BindingListIn :";"
        LexicalDeclarationYield             < LetOrConst BindingListYield :";"
        LexicalDeclarationInYield           < LetOrConst BindingListInYield :";"
        LetOrConst                          < ("let" / "const")

        BindingList                         < LexicalBinding (:"," LexicalBinding)*
        BindingListIn                       < LexicalBindingIn (:"," LexicalBindingIn)*
        BindingListYield                    < LexicalBindingYield (:"," LexicalBindingYield)*
        BindingListInYield                  < LexicalBindingInYield (:"," LexicalBindingInYield)*

        LexicalBinding                      < (BindingPatternYield Initializer) / (BindingIdentifier Initializer?)
        LexicalBindingIn                    < (BindingPatternYield InitializerIn) / (BindingIdentifier InitializerIn?)
        LexicalBindingYield                 < (BindingPatternYield InitializerYield) / (BindingIdentifierYield InitializerYield?)
        LexicalBindingInYield               < (BindingPatternYield InitializerInYield) / (BindingIdentifierYield InitializerInYield?)

        VariableStatement                   < :"var" VariableDeclarationListIn
        VariableStatementYield              < :"var" VariableDeclarationListInYield

        VariableDeclarationList             < VariableDeclaration (:"," VariableDeclaration)*
        VariableDeclarationListIn           < VariableDeclarationIn (:"," VariableDeclarationIn)*
        VariableDeclarationListYield        < VariableDeclarationYield (:"," VariableDeclarationYield)*
        VariableDeclarationListInYield      < VariableDeclarationInYield (:"," VariableDeclarationInYield)*

        VariableDeclaration             < (BindingPattern Initializer) / (BindingIdentifier Initializer?)
        VariableDeclarationIn           < (BindingPattern InitializerIn) / (BindingIdentifier InitializerIn?)
        VariableDeclarationYield        < (BindingPatternYield InitializerYield) / (BindingIdentifierYield InitializerYield?)
        VariableDeclarationInYield      < (BindingPatternYield InitializerInYield) / (BindingIdentifierYield InitializerInYield?)

        BindingPattern                  < ObjectBindingPattern / ArrayBindingPattern
        BindingPatternYield             < ObjectBindingPatternYield / ArrayBindingPatternYield
        ObjectBindingPattern            < CurlyBrackets((BindingPropertyList (:",")?)?)
        ObjectBindingPatternYield       < CurlyBrackets((BindingPropertyListYield (:",")?)?)

        ArrayBindingPattern             < SquareBrackets(Elision? BindingRestElement?) / SquareBrackets(BindingElementList (:"," Elision? BindingRestElement?)?) / SquareBrackets(BindingElementList)
        ArrayBindingPatternYield        < SquareBrackets(Elision? BindingRestElementYield?) / SquareBrackets(BindingElementListYield (:"," Elision? BindingRestElementYield?)?) / SquareBrackets(BindingElementListYield)
        BindingPropertyList             < BindingProperty (:"," BindingProperty)*
        BindingPropertyListYield        < BindingPropertyYield (:"," BindingPropertyYield)*
        BindingElementList              < BindingElisionElement (:"," BindingElisionElement)*
        BindingElementListYield         < BindingElisionElementYield (:"," BindingElisionElementYield)*
        BindingElisionElement           < Elision? BindingElement
        BindingElisionElementYield      < Elision? BindingElementYield
        BindingProperty                 < (PropertyName ":" BindingElement) / SingleNameBinding
        BindingPropertyYield            < (PropertyNameYield ":" BindingElementYield) / SingleNameBindingYield
        BindingElement                  < (BindingPattern InitializerIn?) / SingleNameBinding
        BindingElementYield             < (BindingPatternYield InitializerInYield?) / SingleNameBindingYield
        SingleNameBinding               < BindingIdentifier InitializerIn?
        SingleNameBindingYield          < BindingIdentifierYield InitializerInYield?
        BindingRestElement              < :"..." BindingIdentifier
        BindingRestElementYield         < :"..." BindingIdentifierYield

        EmptyStatement                  < ";"

        ExpressionStatement             < !("{" / (("function" / "class" / ("let" "[")) !(IdentifierStart / IdentifierPart))) ExpressionIn
        ExpressionStatementYield        < !("{" / (("function" / "class" / ("let" "[")) !(IdentifierStart / IdentifierPart))) ExpressionInYield
        ElseKeyword                     < "else"
        IfStatement                     < :"if" Parentheses(ExpressionIn) Statement (ElseKeyword Statement)?
        IfStatementYield                < :"if" Parentheses(ExpressionInYield) StatementYield (ElseKeyword StatementYield)?
        IfStatementReturn               < :"if" Parentheses(ExpressionIn) StatementReturn (ElseKeyword StatementReturn)?
        IfStatementYieldReturn          < :"if" Parentheses(ExpressionInYield) StatementYieldReturn (ElseKeyword StatementYieldReturn)?

        DoKeyword                       <- "do" !(IdentifierStart / IdentifierPart)
        WhileKeyword                    < "while"
        ForKeyword                      < "for"
        VarKeyword                      < "var"
        InKeyword                       < "in"
        OfKeyword                       < "of"
        Semicolon                       < ";"
        IterationStatement              < 
                                            / (DoKeyword Statement WhileKeyword Parentheses(ExpressionIn) Semicolon)
                                            / (WhileKeyword Parentheses(ExpressionIn) Statement)
                                            / (ForKeyword Parentheses(VarKeyword VariableDeclarationList Semicolon ExpressionIn? Semicolon ExpressionIn?) Statement)
                                            / (ForKeyword Parentheses(VarKeyword ForBinding ((InKeyword ExpressionIn) / (OfKeyword AssignmentExpressionIn))) Statement)
                                            / (ForKeyword Parentheses(ForDeclaration InKeyword ExpressionIn) Statement)
                                            / (ForKeyword Parentheses(ForDeclaration OfKeyword AssignmentExpressionIn) Statement)
                                            / (ForKeyword Parentheses(LexicalDeclaration ExpressionIn? Semicolon ExpressionIn?) Statement)
                                            / (ForKeyword Parentheses(!("let" "[") Expression? Semicolon ExpressionIn? Semicolon ExpressionIn?) Statement)
                                            / (ForKeyword Parentheses(!("let" "[") LeftHandSideExpression InKeyword ExpressionIn) Statement)
                                            / (ForKeyword Parentheses(!("let") LeftHandSideExpression OfKeyword AssignmentExpressionIn) Statement)
        IterationStatementYield         < 
                                            / (DoKeyword StatementYield WhileKeyword Parentheses(ExpressionInYield) Semicolon)
                                            / (WhileKeyword Parentheses(ExpressionInYield) StatementYield)
                                            / (ForKeyword Parentheses(VarKeyword VariableDeclarationListYield Semicolon ExpressionInYield? Semicolon ExpressionInYield?) StatementYield)
                                            / (ForKeyword Parentheses(VarKeyword ForBindingYield ((InKeyword ExpressionInYield) / (OfKeyword AssignmentExpressionInYield))) StatementYield)
                                            / (ForKeyword Parentheses(ForDeclarationYield InKeyword ExpressionInYield) StatementYield)
                                            / (ForKeyword Parentheses(ForDeclarationYield OfKeyword AssignmentExpressionInYield) StatementYield)
                                            / (ForKeyword Parentheses(LexicalDeclarationYield ExpressionInYield? Semicolon ExpressionInYield?) StatementYield)
                                            / (ForKeyword Parentheses(!("let" "[") ExpressionYield? Semicolon ExpressionInYield? Semicolon ExpressionInYield?) StatementYield)
                                            / (ForKeyword Parentheses(!("let" "[") LeftHandSideExpressionYield InKeyword ExpressionInYield) StatementYield)
                                            / (ForKeyword Parentheses(!("let") LeftHandSideExpressionYield OfKeyword AssignmentExpressionInYield) StatementYield)
        IterationStatementReturn        < 
                                            / (DoKeyword StatementReturn WhileKeyword Parentheses(ExpressionIn) Semicolon)
                                            / (WhileKeyword Parentheses(ExpressionIn) StatementReturn)
                                            / (ForKeyword Parentheses(VarKeyword VariableDeclarationList Semicolon ExpressionIn? Semicolon ExpressionIn?) StatementReturn)
                                            / (ForKeyword Parentheses(VarKeyword ForBinding ((InKeyword ExpressionIn) / (OfKeyword AssignmentExpressionIn))) StatementReturn)
                                            / (ForKeyword Parentheses(ForDeclaration InKeyword ExpressionIn) StatementReturn)
                                            / (ForKeyword Parentheses(ForDeclaration OfKeyword AssignmentExpressionIn) StatementReturn)
                                            / (ForKeyword Parentheses(LexicalDeclaration ExpressionIn? Semicolon ExpressionIn?) StatementReturn)
                                            / (ForKeyword Parentheses(!("let" "[") Expression? Semicolon ExpressionIn? Semicolon ExpressionIn?) StatementReturn)
                                            / (ForKeyword Parentheses(!("let" "[") LeftHandSideExpression InKeyword ExpressionIn) StatementReturn)
                                            / (ForKeyword Parentheses(!("let") LeftHandSideExpression OfKeyword AssignmentExpressionIn) StatementReturn)
        IterationStatementYieldReturn   < 
                                            / (DoKeyword StatementYieldReturn WhileKeyword Parentheses(ExpressionInYield) Semicolon)
                                            / (WhileKeyword Parentheses(ExpressionInYield) StatementYieldReturn)
                                            / (ForKeyword Parentheses(VarKeyword VariableDeclarationListYield Semicolon ExpressionInYield? Semicolon ExpressionInYield?) StatementYieldReturn)
                                            / (ForKeyword Parentheses(VarKeyword ForBindingYield ((InKeyword ExpressionInYield) / (OfKeyword AssignmentExpressionInYield))) StatementYieldReturn)
                                            / (ForKeyword Parentheses(ForDeclarationYield InKeyword ExpressionInYield) StatementYieldReturn)
                                            / (ForKeyword Parentheses(ForDeclarationYield OfKeyword AssignmentExpressionInYield) StatementYieldReturn)
                                            / (ForKeyword Parentheses(LexicalDeclarationYield ExpressionInYield? Semicolon ExpressionInYield?) StatementYieldReturn)
                                            / (ForKeyword Parentheses(!("let" "[") ExpressionYield? Semicolon ExpressionInYield? Semicolon ExpressionInYield?) StatementYieldReturn)
                                            / (ForKeyword Parentheses(!("let" "[") LeftHandSideExpressionYield InKeyword ExpressionInYield) StatementYieldReturn)
                                            / (ForKeyword Parentheses(!("let") LeftHandSideExpressionYield OfKeyword AssignmentExpressionInYield) StatementYieldReturn)

        ForDeclaration              < LetOrConst ForBinding
        ForDeclarationYield         < LetOrConst ForBindingYield
        ForBinding                  < BindingPattern / BindingIdentifier
        ForBindingYield             < BindingPatternYield / BindingIdentifierYield
        ContinueStatement           <- (("continue" !(IdentifierStart) Spaces LabelIdentifier) / ("continue" !(IdentifierStart / IdentifierPart))) Spaces :";"?
        ContinueStatementYield      <- (("continue" !(IdentifierStart) Spaces LabelIdentifierYield) / ("continue" !(IdentifierStart / IdentifierPart))) Spaces :";"?
        BreakStatement              <- (("break" !(IdentifierStart) Spaces LabelIdentifier) / ("break" !(IdentifierStart / IdentifierPart))) Spaces :";"?
        BreakStatementYield         <- (("break" !(IdentifierStart) Spaces LabelIdentifierYield) / ("break" !(IdentifierStart / IdentifierPart))) Spaces :";"?
        ReturnStatement             <- (("return" !(IdentifierStart) Spaces ExpressionIn) / ("return" !(IdentifierStart / IdentifierPart))) Spaces :";"?
        ReturnStatementYield        <- (("return" !(IdentifierStart) Spaces ExpressionInYield) / ("return" !(IdentifierStart / IdentifierPart))) Spaces :";"?

        WithStatement               < :"with" Parentheses(ExpressionIn) Statement
        WithStatementYield          < :"with" Parentheses(ExpressionInYield) StatementYield
        WithStatementReturn         < :"with" Parentheses(ExpressionIn) StatementReturn
        WithStatementYieldReturn    < :"with" Parentheses(ExpressionInYield) StatementYieldReturn

        SwitchStatement             < :"switch" Parentheses(ExpressionIn) CaseBlock
        SwitchStatementYield        < :"switch" Parentheses(ExpressionInYield) CaseBlockYield
        SwitchStatementReturn       < :"switch" Parentheses(ExpressionIn) CaseBlockReturn
        SwitchStatementYieldReturn  < :"switch" Parentheses(ExpressionInYield) CaseBlockYieldReturn

        CaseBlock                   < CurlyBrackets(CaseClauses? DefaultClause? CaseClauses?)
        CaseBlockYield              < CurlyBrackets(CaseClausesYield? DefaultClauseYield? CaseClausesYield?)
        CaseBlockReturn             < CurlyBrackets(CaseClausesReturn? DefaultClauseReturn? CaseClausesReturn?)
        CaseBlockYieldReturn        < CurlyBrackets(CaseClausesYieldReturn? DefaultClauseYieldReturn? CaseClausesYieldReturn?)

        CaseClauses                 < CaseClause+
        CaseClausesYield            < CaseClauseYield+
        CaseClausesReturn           < CaseClauseReturn+
        CaseClausesYieldReturn      < CaseClauseYieldReturn+

        CaseClause                  < :"case" ExpressionIn :":" StatementList?
        CaseClauseYield             < :"case" ExpressionInYield :":" StatementListYield?
        CaseClauseReturn            < :"case" ExpressionIn :":" StatementListReturn?
        CaseClauseYieldReturn       < :"case" ExpressionInYield :":" StatementListYieldReturn?

        DefaultClause               < :"default" :":" StatementList?
        DefaultClauseYield          < :"default" :":" StatementListYield?
        DefaultClauseReturn         < :"default" :":" StatementListReturn?
        DefaultClauseYieldReturn    < :"default" :":" StatementListYieldReturn?

        LabelledStatement               < LabelIdentifier :":" LabelledItem
        LabelledStatementYield          < LabelIdentifierYield :":" LabelledItemYield
        LabelledStatementReturn         < LabelIdentifier :":" LabelledItemReturn
        LabelledStatementYieldReturn    < LabelIdentifierYield :":" LabelledItemYieldReturn

        LabelledItem                < FunctionDeclaration / Statement
        LabelledItemYield           < FunctionDeclarationYield / StatementYield
        LabelledItemReturn          < FunctionDeclaration / StatementReturn
        LabelledItemYieldReturn     < FunctionDeclarationYield / StatementYieldReturn

        ThrowStatement              <- "throw" !(IdentifierStart) Spaces ExpressionIn Spaces :";"?
        ThrowStatementYield         <- "throw" !(IdentifierStart) Spaces ExpressionInYield Spaces :";"?

        TryStatement                < :"try" %Block Catch? Finally?
        TryStatementYield           < :"try" %BlockYield CatchYield? FinallyYield?
        TryStatementReturn          < :"try" %BlockReturn CatchReturn? FinallyReturn?
        TryStatementYieldReturn     < :"try" %BlockYieldReturn CatchYieldReturn? FinallyYieldReturn?

        Catch                       < :"catch" Parentheses(CatchParameter) %Block
        CatchYield                  < :"catch" Parentheses(CatchParameterYield) %BlockYield
        CatchReturn                 < :"catch" Parentheses(CatchParameter) %BlockReturn
        CatchYieldReturn            < :"catch" Parentheses(CatchParameterYield) %BlockYieldReturn

        Finally                     < :"finally" %Block
        FinallyYield                < :"finally" %BlockYield
        FinallyReturn               < :"finally" %BlockReturn
        FinallyYieldReturn          < :"finally" %BlockYieldReturn

        CatchParameter              < BindingPattern / BindingIdentifier
        CatchParameterYield         < BindingPatternYield / BindingIdentifierYield

        DebuggerStatement               < :"debugger" :";"
        CurlyBrackets(Content)          < "{" Content "}"
        Parentheses(Content)            < "(" Content ")"
        SquareBrackets(Content)         < "[" Content "]"

        FunctionDeclaration                 < (:"function" BindingIdentifier Parentheses(FormalParameters) CurlyBrackets(FunctionBody))
        FunctionDeclarationYield            < (:"function" BindingIdentifierYield Parentheses(FormalParameters) CurlyBrackets(FunctionBody))
        FunctionDeclarationDefault          < (:"function" BindingIdentifier Parentheses(FormalParameters) CurlyBrackets(FunctionBody)) / (:"function" Parentheses(FormalParameters) CurlyBrackets(FunctionBody))
        FunctionDeclarationYieldDefault     < (:"function" BindingIdentifierYield Parentheses(FormalParameters) CurlyBrackets(FunctionBody)) / (:"function" Parentheses(FormalParameters) CurlyBrackets(FunctionBody))
        
        FunctionExpression                  < "function" BindingIdentifier? Parentheses(FormalParameters) CurlyBrackets(FunctionBody)

        StrictFormalParameters          < FormalParameters
        StrictFormalParametersYield     < FormalParametersYield
        FormalParameters                < FormalParameterList?
        FormalParametersYield           < FormalParameterListYield?
        FormalParameterList             < FunctionRestParameter / (FormalsList (:"," FunctionRestParameter)?)
        FormalParameterListYield        < FunctionRestParameterYield / (FormalsListYield (:"," FunctionRestParameterYield)?)
        FormalsList                     < FormalParameter (:"," FormalParameter)*
        FormalsListYield                < FormalParameterYield (:"," FormalParameterYield)*
        FunctionRestParameter           < BindingRestElement
        FunctionRestParameterYield      < BindingRestElementYield
        FormalParameter                 < BindingElement
        FormalParameterYield            < BindingElementYield
        FunctionBody                    < FunctionStatementList
        FunctionBodyYield               < FunctionStatementListYield
        FunctionStatementList           < StatementListReturn?
        FunctionStatementListYield      < StatementListYieldReturn?
        ArrowFunction                   <- ArrowParameters Spaces "=>" Spacing ConciseBody
        ArrowFunctionIn                 <- ArrowParameters Spaces "=>" Spacing ConciseBodyIn
        ArrowFunctionYield              <- ArrowParametersYield Spaces "=>" Spacing ConciseBody
        ArrowFunctionInYield            <- ArrowParametersYield Spaces "=>" Spacing ConciseBodyIn
        ArrowParameters                 < BindingIdentifier / CoverParenthesizedExpressionAndArrowParameterList
        ArrowParametersYield            < BindingIdentifierYield / CoverParenthesizedExpressionAndArrowParameterListYield
        ConciseBody                     < (!("{") AssignmentExpression) / CurlyBrackets(FunctionBody)
        ConciseBodyIn                   < (!("{") AssignmentExpressionIn) / CurlyBrackets(FunctionBody)

        ArrowFormalParameters               < Parentheses(StrictFormalParameters)
        ArrowFormalParametersYield          < Parentheses(StrictFormalParametersYield)
        MethodDefinition                    < GeneratorMethod / ("get" PropertyName "(" ")" CurlyBrackets(FunctionBody)) / ("set" PropertyName Parentheses(PropertySetParameterList) CurlyBrackets(FunctionBody)) / (PropertyName Parentheses(StrictFormalParameters) CurlyBrackets(FunctionBody))
        MethodDefinitionYield               < GeneratorMethodYield / ("get" PropertyNameYield "(" ")" CurlyBrackets(FunctionBody)) / ("set" PropertyNameYield Parentheses(PropertySetParameterList) CurlyBrackets(FunctionBody)) / (PropertyNameYield Parentheses(StrictFormalParameters) CurlyBrackets(FunctionBody))
        PropertySetParameterList            < FormalParameter
        GeneratorMethod                     < :"*" PropertyName Parentheses(StrictFormalParameters) CurlyBrackets(GeneratorBody)
        GeneratorMethodYield                < :"*" PropertyNameYield Parentheses(StrictFormalParametersYield) CurlyBrackets(GeneratorBody)
        GeneratorDeclaration                < :"function" :"*" BindingIdentifier Parentheses(FormalParameters) CurlyBrackets(GeneratorBody)
        GeneratorDeclarationYield           < :"function" :"*" BindingIdentifierYield Parentheses(FormalParametersYield) CurlyBrackets(GeneratorBody)
        GeneratorDeclarationDefault         < :"function" :"*" BindingIdentifier? Parentheses(FormalParameters) CurlyBrackets(GeneratorBody)
        GeneratorDeclarationYieldDefault    < :"function" :"*" BindingIdentifierYield? Parentheses(FormalParametersYield) CurlyBrackets(GeneratorBody)
        GeneratorExpression                 < :"function" :"*" BindingIdentifierYield? Parentheses(FormalParametersYield) CurlyBrackets(GeneratorBody)
        GeneratorBody                       < FunctionBodyYield
        YieldExpression                     <- ("yield" Spaces ("*")? AssignmentExpressionYield) / "yield"
        YieldExpressionIn                   <- ("yield" Spaces ("*")? AssignmentExpressionInYield) / "yield"
        ClassDeclaration                    <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifier Spaces ClassTail
        ClassDeclarationYield               <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifierYield Spaces ClassTailYield
        ClassDeclarationDefault             <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifier? Spaces ClassTail
        ClassDeclarationYieldDefault        <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifierYield? Spaces ClassTailYield
        ClassExpression                     <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifier? Spaces ClassTail
        ClassExpressionYield                <- :"class" !(IdentifierStart / IdentifierPart) Spaces BindingIdentifierYield? Spaces ClassTailYield
        ClassTail                           < ClassHeritage? CurlyBrackets(ClassBody?)
        ClassTailYield                      < ClassHeritageYield? CurlyBrackets(ClassBodyYield?)
        ClassHeritage                       < :"extends" LeftHandSideExpression
        ClassHeritageYield                  < :"extends" LeftHandSideExpressionYield
        ClassBody                           < ClassElementList 
        ClassBodyYield                      < ClassElementListYield 
        ClassElementList                    < ClassElement+
        ClassElementListYield               < ClassElementYield+
        ClassElement                        < ("static" MethodDefinition) / :";" / MethodDefinition
        ClassElementYield                   < ("static" MethodDefinitionYield) / :";" / MethodDefinitionYield

        JSXElement                      < "<" JSXTag JSXAttributeSet ("/>" / (">" JSXContent "</" JSXTag ">"))
        JSXAttributeSet                 < JSXAttribute*
        JSXAttribute                    < CurlyBrackets(SpreadElement) / (JSXKey ("=" JSXValue)?)
        JSXKey                          <~ (!("=" / "/>" / ">") .)+
        JSXInlineJS                     < ArrowFunction / ConditionalExpression
        JSXValue                        < StringLiteral / JSXCodeBlock
        JSXCodeBlock                    < CurlyBrackets(JSXInlineJS)
        JSXJavaScriptValue              < CurlyBrackets(!JSXElement JSXInlineJS)
        JSXTag                          <~ [a-zA-Z][a-zA-Z0-9]*
        JSXContent                      < (JSXElement / JSXCodeBlock / JSXContentText)*
        JSXContentText                  <~ (!"</" SourceCharacter)*
    

+/
module es6.grammar;

public import pegged.peg;
import std.algorithm: startsWith;
import std.functional: toDelegate;

struct GenericES6(TParseTree)
{
    import pegged.dynamic.grammar;
    struct ES6
    {
    enum name = "ES6";
    static ParseTree delegate(ParseTree)[string] before;
    static ParseTree delegate(ParseTree)[string] after;
    static ParseTree delegate(ParseTree)[string] rules;

    static this()
    {
        rules["Module"] = toDelegate(&Module);
        rules["ModuleBody"] = toDelegate(&ModuleBody);
        rules["ModuleItemList"] = toDelegate(&ModuleItemList);
        rules["ImportDeclaration"] = toDelegate(&ImportDeclaration);
        rules["ImportClause"] = toDelegate(&ImportClause);
        rules["ImportedDefaultBinding"] = toDelegate(&ImportedDefaultBinding);
        rules["NameSpaceImport"] = toDelegate(&NameSpaceImport);
        rules["NamedImports"] = toDelegate(&NamedImports);
        rules["FromClause"] = toDelegate(&FromClause);
        rules["ImportsList"] = toDelegate(&ImportsList);
        rules["ImportSpecifier"] = toDelegate(&ImportSpecifier);
        rules["ModuleSpecifier"] = toDelegate(&ModuleSpecifier);
        rules["ImportedBinding"] = toDelegate(&ImportedBinding);
        rules["ExportDeclaration"] = toDelegate(&ExportDeclaration);
        rules["ExportClause"] = toDelegate(&ExportClause);
        rules["ExportsList"] = toDelegate(&ExportsList);
        rules["ExportSpecifier"] = toDelegate(&ExportSpecifier);
        rules["SourceCharacter"] = toDelegate(&SourceCharacter);
        rules["InputElementDiv"] = toDelegate(&InputElementDiv);
        rules["InputElementRegExp"] = toDelegate(&InputElementRegExp);
        rules["InputElementRegExpOrTemplateTail"] = toDelegate(&InputElementRegExpOrTemplateTail);
        rules["InputElementTemplateTail"] = toDelegate(&InputElementTemplateTail);
        rules["WhiteSpace"] = toDelegate(&WhiteSpace);
        rules["LineTerminator"] = toDelegate(&LineTerminator);
        rules["LineTerminatorSequence"] = toDelegate(&LineTerminatorSequence);
        rules["Spacing"] = toDelegate(&Spacing);
   }

    template hooked(alias r, string name)
    {
        static ParseTree hooked(ParseTree p)
        {
            ParseTree result;

            if (name in before)
            {
                result = before[name](p);
                if (result.successful)
                    return result;
            }

            result = r(p);
            if (result.successful || name !in after)
                return result;

            result = after[name](p);
            return result;
        }

        static ParseTree hooked(string input)
        {
            return hooked!(r, name)(ParseTree("",false,[],input));
        }
    }

    static void addRuleBefore(string parentRule, string ruleSyntax)
    {
        // enum name is the current grammar name
        DynamicGrammar dg = pegged.dynamic.grammar.grammar(name ~ ": " ~ ruleSyntax, rules);
        foreach(ruleName,rule; dg.rules)
            if (ruleName != "Spacing") // Keep the local Spacing rule, do not overwrite it
                rules[ruleName] = rule;
        before[parentRule] = rules[dg.startingRule];
    }

    static void addRuleAfter(string parentRule, string ruleSyntax)
    {
        // enum name is the current grammar named
        DynamicGrammar dg = pegged.dynamic.grammar.grammar(name ~ ": " ~ ruleSyntax, rules);
        foreach(name,rule; dg.rules)
        {
            if (name != "Spacing")
                rules[name] = rule;
        }
        after[parentRule] = rules[dg.startingRule];
    }

    static bool isRule(string s)
    {
        return s.startsWith("ES6.");
    }
    import std.typecons:Tuple, tuple;
    static TParseTree[Tuple!(string, size_t)] memo;
    mixin decimateTree;
    static TParseTree Module(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ModuleBody, Spacing), pegged.peg.wrapAround!(Spacing, eoi, Spacing)), "ES6.Module")(p);
        }
        else
        {
            if(auto m = tuple(`Module`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ModuleBody, Spacing), pegged.peg.wrapAround!(Spacing, eoi, Spacing)), "ES6.Module"), "Module")(p);
                memo[tuple(`Module`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Module(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ModuleBody, Spacing), pegged.peg.wrapAround!(Spacing, eoi, Spacing)), "ES6.Module")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ModuleBody, Spacing), pegged.peg.wrapAround!(Spacing, eoi, Spacing)), "ES6.Module"), "Module")(TParseTree("", false,[], s));
        }
    }
    static string Module(GetName g)
    {
        return "ES6.Module";
    }

    static TParseTree ModuleBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ModuleItemList, Spacing), "ES6.ModuleBody")(p);
        }
        else
        {
            if(auto m = tuple(`ModuleBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ModuleItemList, Spacing), "ES6.ModuleBody"), "ModuleBody")(p);
                memo[tuple(`ModuleBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ModuleBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ModuleItemList, Spacing), "ES6.ModuleBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ModuleItemList, Spacing), "ES6.ModuleBody"), "ModuleBody")(TParseTree("", false,[], s));
        }
    }
    static string ModuleBody(GetName g)
    {
        return "ES6.ModuleBody";
    }

    static TParseTree ModuleItemList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ImportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ExportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), Spacing)), "ES6.ModuleItemList")(p);
        }
        else
        {
            if(auto m = tuple(`ModuleItemList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ImportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ExportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), Spacing)), "ES6.ModuleItemList"), "ModuleItemList")(p);
                memo[tuple(`ModuleItemList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ModuleItemList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ImportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ExportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), Spacing)), "ES6.ModuleItemList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ImportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ExportDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), Spacing)), "ES6.ModuleItemList"), "ModuleItemList")(TParseTree("", false,[], s));
        }
    }
    static string ModuleItemList(GetName g)
    {
        return "ES6.ModuleItemList";
    }

    static TParseTree ImportDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("import"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), "ES6.ImportDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`ImportDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("import"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), "ES6.ImportDeclaration"), "ImportDeclaration")(p);
                memo[tuple(`ImportDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("import"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), "ES6.ImportDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("import"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), "ES6.ImportDeclaration"), "ImportDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string ImportDeclaration(GetName g)
    {
        return "ES6.ImportDeclaration";
    }

    static TParseTree ImportClause(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing)), "ES6.ImportClause")(p);
        }
        else
        {
            if(auto m = tuple(`ImportClause`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing)), "ES6.ImportClause"), "ImportClause")(p);
                memo[tuple(`ImportClause`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportClause(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing)), "ES6.ImportClause")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NameSpaceImport, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, NamedImports, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedDefaultBinding, Spacing)), "ES6.ImportClause"), "ImportClause")(TParseTree("", false,[], s));
        }
    }
    static string ImportClause(GetName g)
    {
        return "ES6.ImportClause";
    }

    static TParseTree ImportedDefaultBinding(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing), "ES6.ImportedDefaultBinding")(p);
        }
        else
        {
            if(auto m = tuple(`ImportedDefaultBinding`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing), "ES6.ImportedDefaultBinding"), "ImportedDefaultBinding")(p);
                memo[tuple(`ImportedDefaultBinding`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportedDefaultBinding(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing), "ES6.ImportedDefaultBinding")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing), "ES6.ImportedDefaultBinding"), "ImportedDefaultBinding")(TParseTree("", false,[], s));
        }
    }
    static string ImportedDefaultBinding(GetName g)
    {
        return "ES6.ImportedDefaultBinding";
    }

    static TParseTree NameSpaceImport(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.NameSpaceImport")(p);
        }
        else
        {
            if(auto m = tuple(`NameSpaceImport`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.NameSpaceImport"), "NameSpaceImport")(p);
                memo[tuple(`NameSpaceImport`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NameSpaceImport(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.NameSpaceImport")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.NameSpaceImport"), "NameSpaceImport")(TParseTree("", false,[], s));
        }
    }
    static string NameSpaceImport(GetName g)
    {
        return "ES6.NameSpaceImport";
    }

    static TParseTree NamedImports(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.NamedImports")(p);
        }
        else
        {
            if(auto m = tuple(`NamedImports`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.NamedImports"), "NamedImports")(p);
                memo[tuple(`NamedImports`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NamedImports(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.NamedImports")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.NamedImports"), "NamedImports")(TParseTree("", false,[], s));
        }
    }
    static string NamedImports(GetName g)
    {
        return "ES6.NamedImports";
    }

    static TParseTree FromClause(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("from"), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), "ES6.FromClause")(p);
        }
        else
        {
            if(auto m = tuple(`FromClause`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("from"), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), "ES6.FromClause"), "FromClause")(p);
                memo[tuple(`FromClause`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FromClause(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("from"), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), "ES6.FromClause")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("from"), Spacing), pegged.peg.wrapAround!(Spacing, ModuleSpecifier, Spacing)), "ES6.FromClause"), "FromClause")(TParseTree("", false,[], s));
        }
    }
    static string FromClause(GetName g)
    {
        return "ES6.FromClause";
    }

    static TParseTree ImportsList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing)), Spacing))), "ES6.ImportsList")(p);
        }
        else
        {
            if(auto m = tuple(`ImportsList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing)), Spacing))), "ES6.ImportsList"), "ImportsList")(p);
                memo[tuple(`ImportsList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportsList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing)), Spacing))), "ES6.ImportsList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ImportSpecifier, Spacing)), Spacing))), "ES6.ImportsList"), "ImportsList")(TParseTree("", false,[], s));
        }
    }
    static string ImportsList(GetName g)
    {
        return "ES6.ImportsList";
    }

    static TParseTree ImportSpecifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.ImportSpecifier")(p);
        }
        else
        {
            if(auto m = tuple(`ImportSpecifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.ImportSpecifier"), "ImportSpecifier")(p);
                memo[tuple(`ImportSpecifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportSpecifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.ImportSpecifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, ImportedBinding, Spacing)), "ES6.ImportSpecifier"), "ImportSpecifier")(TParseTree("", false,[], s));
        }
    }
    static string ImportSpecifier(GetName g)
    {
        return "ES6.ImportSpecifier";
    }

    static TParseTree ModuleSpecifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), "ES6.ModuleSpecifier")(p);
        }
        else
        {
            if(auto m = tuple(`ModuleSpecifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), "ES6.ModuleSpecifier"), "ModuleSpecifier")(p);
                memo[tuple(`ModuleSpecifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ModuleSpecifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), "ES6.ModuleSpecifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), "ES6.ModuleSpecifier"), "ModuleSpecifier")(TParseTree("", false,[], s));
        }
    }
    static string ModuleSpecifier(GetName g)
    {
        return "ES6.ModuleSpecifier";
    }

    static TParseTree ImportedBinding(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), "ES6.ImportedBinding")(p);
        }
        else
        {
            if(auto m = tuple(`ImportedBinding`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), "ES6.ImportedBinding"), "ImportedBinding")(p);
                memo[tuple(`ImportedBinding`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ImportedBinding(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), "ES6.ImportedBinding")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), "ES6.ImportedBinding"), "ImportedBinding")(TParseTree("", false,[], s));
        }
    }
    static string ImportedBinding(GetName g)
    {
        return "ES6.ImportedBinding";
    }

    static TParseTree ExportDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, HoistableDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, Declaration, Spacing)), Spacing)), "ES6.ExportDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`ExportDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, HoistableDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, Declaration, Spacing)), Spacing)), "ES6.ExportDeclaration"), "ExportDeclaration")(p);
                memo[tuple(`ExportDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExportDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, HoistableDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, Declaration, Spacing)), Spacing)), "ES6.ExportDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, FromClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, ExportClause, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, HoistableDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationDefault, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("export"), Spacing), pegged.peg.wrapAround!(Spacing, Declaration, Spacing)), Spacing)), "ES6.ExportDeclaration"), "ExportDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string ExportDeclaration(GetName g)
    {
        return "ES6.ExportDeclaration";
    }

    static TParseTree ExportClause(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.ExportClause")(p);
        }
        else
        {
            if(auto m = tuple(`ExportClause`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.ExportClause"), "ExportClause")(p);
                memo[tuple(`ExportClause`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExportClause(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.ExportClause")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), Spacing))), Spacing))), Spacing), "ES6.ExportClause"), "ExportClause")(TParseTree("", false,[], s));
        }
    }
    static string ExportClause(GetName g)
    {
        return "ES6.ExportClause";
    }

    static TParseTree ExportsList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing)), Spacing))), "ES6.ExportsList")(p);
        }
        else
        {
            if(auto m = tuple(`ExportsList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing)), Spacing))), "ES6.ExportsList"), "ExportsList")(p);
                memo[tuple(`ExportsList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExportsList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing)), Spacing))), "ES6.ExportsList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ExportSpecifier, Spacing)), Spacing))), "ES6.ExportsList"), "ExportsList")(TParseTree("", false,[], s));
        }
    }
    static string ExportsList(GetName g)
    {
        return "ES6.ExportsList";
    }

    static TParseTree ExportSpecifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), Spacing))), "ES6.ExportSpecifier")(p);
        }
        else
        {
            if(auto m = tuple(`ExportSpecifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), Spacing))), "ES6.ExportSpecifier"), "ExportSpecifier")(p);
                memo[tuple(`ExportSpecifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExportSpecifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), Spacing))), "ES6.ExportSpecifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("as"), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), Spacing))), "ES6.ExportSpecifier"), "ExportSpecifier")(TParseTree("", false,[], s));
        }
    }
    static string ExportSpecifier(GetName g)
    {
        return "ES6.ExportSpecifier";
    }

    static TParseTree SourceCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('\u0000', '\uFFFC'), "ES6.SourceCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`SourceCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.charRange!('\u0000', '\uFFFC'), "ES6.SourceCharacter"), "SourceCharacter")(p);
                memo[tuple(`SourceCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SourceCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('\u0000', '\uFFFC'), "ES6.SourceCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.charRange!('\u0000', '\uFFFC'), "ES6.SourceCharacter"), "SourceCharacter")(TParseTree("", false,[], s));
        }
    }
    static string SourceCharacter(GetName g)
    {
        return "ES6.SourceCharacter";
    }

    static TParseTree InputElementDiv(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, RightBracePunctuator), "ES6.InputElementDiv")(p);
        }
        else
        {
            if(auto m = tuple(`InputElementDiv`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, RightBracePunctuator), "ES6.InputElementDiv"), "InputElementDiv")(p);
                memo[tuple(`InputElementDiv`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InputElementDiv(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, RightBracePunctuator), "ES6.InputElementDiv")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, RightBracePunctuator), "ES6.InputElementDiv"), "InputElementDiv")(TParseTree("", false,[], s));
        }
    }
    static string InputElementDiv(GetName g)
    {
        return "ES6.InputElementDiv";
    }

    static TParseTree InputElementRegExp(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RightBracePunctuator, RegularExpressionLiteral), "ES6.InputElementRegExp")(p);
        }
        else
        {
            if(auto m = tuple(`InputElementRegExp`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RightBracePunctuator, RegularExpressionLiteral), "ES6.InputElementRegExp"), "InputElementRegExp")(p);
                memo[tuple(`InputElementRegExp`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InputElementRegExp(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RightBracePunctuator, RegularExpressionLiteral), "ES6.InputElementRegExp")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RightBracePunctuator, RegularExpressionLiteral), "ES6.InputElementRegExp"), "InputElementRegExp")(TParseTree("", false,[], s));
        }
    }
    static string InputElementRegExp(GetName g)
    {
        return "ES6.InputElementRegExp";
    }

    static TParseTree InputElementRegExpOrTemplateTail(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RegularExpressionLiteral, TemplateSubstitutionTail), "ES6.InputElementRegExpOrTemplateTail")(p);
        }
        else
        {
            if(auto m = tuple(`InputElementRegExpOrTemplateTail`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RegularExpressionLiteral, TemplateSubstitutionTail), "ES6.InputElementRegExpOrTemplateTail"), "InputElementRegExpOrTemplateTail")(p);
                memo[tuple(`InputElementRegExpOrTemplateTail`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InputElementRegExpOrTemplateTail(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RegularExpressionLiteral, TemplateSubstitutionTail), "ES6.InputElementRegExpOrTemplateTail")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, RegularExpressionLiteral, TemplateSubstitutionTail), "ES6.InputElementRegExpOrTemplateTail"), "InputElementRegExpOrTemplateTail")(TParseTree("", false,[], s));
        }
    }
    static string InputElementRegExpOrTemplateTail(GetName g)
    {
        return "ES6.InputElementRegExpOrTemplateTail";
    }

    static TParseTree InputElementTemplateTail(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, TemplateSubstitutionTail), "ES6.InputElementTemplateTail")(p);
        }
        else
        {
            if(auto m = tuple(`InputElementTemplateTail`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, TemplateSubstitutionTail), "ES6.InputElementTemplateTail"), "InputElementTemplateTail")(p);
                memo[tuple(`InputElementTemplateTail`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InputElementTemplateTail(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, TemplateSubstitutionTail), "ES6.InputElementTemplateTail")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(WhiteSpace, LineTerminator, Comment, CommonToken, DivPunctuator, TemplateSubstitutionTail), "ES6.InputElementTemplateTail"), "InputElementTemplateTail")(TParseTree("", false,[], s));
        }
    }
    static string InputElementTemplateTail(GetName g)
    {
        return "ES6.InputElementTemplateTail";
    }

    static TParseTree WhiteSpace(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u0009"), pegged.peg.literal!("\u000B"), pegged.peg.literal!("\u000C"), pegged.peg.literal!("\u0020"), pegged.peg.literal!("\u00A0"), pegged.peg.literal!("\uFEFF"), pegged.peg.charRange!('\u02B0', '\u02FF')), "ES6.WhiteSpace")(p);
        }
        else
        {
            if(auto m = tuple(`WhiteSpace`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u0009"), pegged.peg.literal!("\u000B"), pegged.peg.literal!("\u000C"), pegged.peg.literal!("\u0020"), pegged.peg.literal!("\u00A0"), pegged.peg.literal!("\uFEFF"), pegged.peg.charRange!('\u02B0', '\u02FF')), "ES6.WhiteSpace"), "WhiteSpace")(p);
                memo[tuple(`WhiteSpace`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WhiteSpace(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u0009"), pegged.peg.literal!("\u000B"), pegged.peg.literal!("\u000C"), pegged.peg.literal!("\u0020"), pegged.peg.literal!("\u00A0"), pegged.peg.literal!("\uFEFF"), pegged.peg.charRange!('\u02B0', '\u02FF')), "ES6.WhiteSpace")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u0009"), pegged.peg.literal!("\u000B"), pegged.peg.literal!("\u000C"), pegged.peg.literal!("\u0020"), pegged.peg.literal!("\u00A0"), pegged.peg.literal!("\uFEFF"), pegged.peg.charRange!('\u02B0', '\u02FF')), "ES6.WhiteSpace"), "WhiteSpace")(TParseTree("", false,[], s));
        }
    }
    static string WhiteSpace(GetName g)
    {
        return "ES6.WhiteSpace";
    }

    static TParseTree LineTerminator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("\u000A", "\u000D", "\u2028", "\u2029"), "ES6.LineTerminator")(p);
        }
        else
        {
            if(auto m = tuple(`LineTerminator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("\u000A", "\u000D", "\u2028", "\u2029"), "ES6.LineTerminator"), "LineTerminator")(p);
                memo[tuple(`LineTerminator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LineTerminator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("\u000A", "\u000D", "\u2028", "\u2029"), "ES6.LineTerminator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("\u000A", "\u000D", "\u2028", "\u2029"), "ES6.LineTerminator"), "LineTerminator")(TParseTree("", false,[], s));
        }
    }
    static string LineTerminator(GetName g)
    {
        return "ES6.LineTerminator";
    }

    static TParseTree LineTerminatorSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u000A"), pegged.peg.and!(pegged.peg.literal!("\u000D"), pegged.peg.negLookahead!(pegged.peg.literal!("\u000A"))), pegged.peg.literal!("\u2028"), pegged.peg.literal!("\u2029"), pegged.peg.literal!("\u000D\u000A")), "ES6.LineTerminatorSequence")(p);
        }
        else
        {
            if(auto m = tuple(`LineTerminatorSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u000A"), pegged.peg.and!(pegged.peg.literal!("\u000D"), pegged.peg.negLookahead!(pegged.peg.literal!("\u000A"))), pegged.peg.literal!("\u2028"), pegged.peg.literal!("\u2029"), pegged.peg.literal!("\u000D\u000A")), "ES6.LineTerminatorSequence"), "LineTerminatorSequence")(p);
                memo[tuple(`LineTerminatorSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LineTerminatorSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u000A"), pegged.peg.and!(pegged.peg.literal!("\u000D"), pegged.peg.negLookahead!(pegged.peg.literal!("\u000A"))), pegged.peg.literal!("\u2028"), pegged.peg.literal!("\u2029"), pegged.peg.literal!("\u000D\u000A")), "ES6.LineTerminatorSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u000A"), pegged.peg.and!(pegged.peg.literal!("\u000D"), pegged.peg.negLookahead!(pegged.peg.literal!("\u000A"))), pegged.peg.literal!("\u2028"), pegged.peg.literal!("\u2029"), pegged.peg.literal!("\u000D\u000A")), "ES6.LineTerminatorSequence"), "LineTerminatorSequence")(TParseTree("", false,[], s));
        }
    }
    static string LineTerminatorSequence(GetName g)
    {
        return "ES6.LineTerminatorSequence";
    }

    static TParseTree Spacing(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), pegged.peg.discard!(LineTerminatorSequence), Comment))), "ES6.Spacing")(p);
        }
        else
        {
            if(auto m = tuple(`Spacing`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), pegged.peg.discard!(LineTerminatorSequence), Comment))), "ES6.Spacing"), "Spacing")(p);
                memo[tuple(`Spacing`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Spacing(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), pegged.peg.discard!(LineTerminatorSequence), Comment))), "ES6.Spacing")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), pegged.peg.discard!(LineTerminatorSequence), Comment))), "ES6.Spacing"), "Spacing")(TParseTree("", false,[], s));
        }
    }
    static string Spacing(GetName g)
    {
        return "ES6.Spacing";
    }

    static TParseTree Spaces(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), Comment))), "ES6.Spaces")(p);
        }
        else
        {
            if(auto m = tuple(`Spaces`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), Comment))), "ES6.Spaces"), "Spaces")(p);
                memo[tuple(`Spaces`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Spaces(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), Comment))), "ES6.Spaces")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.discard!(WhiteSpace), Comment))), "ES6.Spaces"), "Spaces")(TParseTree("", false,[], s));
        }
    }
    static string Spaces(GetName g)
    {
        return "ES6.Spaces";
    }

    static TParseTree Comment(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(MultiLineComment, SingleLineComment)), "ES6.Comment")(p);
        }
        else
        {
            if(auto m = tuple(`Comment`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(MultiLineComment, SingleLineComment)), "ES6.Comment"), "Comment")(p);
                memo[tuple(`Comment`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Comment(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(MultiLineComment, SingleLineComment)), "ES6.Comment")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(MultiLineComment, SingleLineComment)), "ES6.Comment"), "Comment")(TParseTree("", false,[], s));
        }
    }
    static string Comment(GetName g)
    {
        return "ES6.Comment";
    }

    static TParseTree MultiLineComment(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("/*")), pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("*/")), SourceCharacter)), pegged.peg.discard!(pegged.peg.literal!("*/")))), "ES6.MultiLineComment")(p);
        }
        else
        {
            if(auto m = tuple(`MultiLineComment`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("/*")), pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("*/")), SourceCharacter)), pegged.peg.discard!(pegged.peg.literal!("*/")))), "ES6.MultiLineComment"), "MultiLineComment")(p);
                memo[tuple(`MultiLineComment`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MultiLineComment(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("/*")), pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("*/")), SourceCharacter)), pegged.peg.discard!(pegged.peg.literal!("*/")))), "ES6.MultiLineComment")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("/*")), pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("*/")), SourceCharacter)), pegged.peg.discard!(pegged.peg.literal!("*/")))), "ES6.MultiLineComment"), "MultiLineComment")(TParseTree("", false,[], s));
        }
    }
    static string MultiLineComment(GetName g)
    {
        return "ES6.MultiLineComment";
    }

    static TParseTree SingleLineComment(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("//")), pegged.peg.option!(SingleLineCommentChars), eol), "ES6.SingleLineComment")(p);
        }
        else
        {
            if(auto m = tuple(`SingleLineComment`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("//")), pegged.peg.option!(SingleLineCommentChars), eol), "ES6.SingleLineComment"), "SingleLineComment")(p);
                memo[tuple(`SingleLineComment`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleLineComment(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("//")), pegged.peg.option!(SingleLineCommentChars), eol), "ES6.SingleLineComment")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("//")), pegged.peg.option!(SingleLineCommentChars), eol), "ES6.SingleLineComment"), "SingleLineComment")(TParseTree("", false,[], s));
        }
    }
    static string SingleLineComment(GetName g)
    {
        return "ES6.SingleLineComment";
    }

    static TParseTree SingleLineCommentChars(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(SingleLineCommentChar), "ES6.SingleLineCommentChars")(p);
        }
        else
        {
            if(auto m = tuple(`SingleLineCommentChars`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(SingleLineCommentChar), "ES6.SingleLineCommentChars"), "SingleLineCommentChars")(p);
                memo[tuple(`SingleLineCommentChars`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleLineCommentChars(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(SingleLineCommentChar), "ES6.SingleLineCommentChars")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(SingleLineCommentChar), "ES6.SingleLineCommentChars"), "SingleLineCommentChars")(TParseTree("", false,[], s));
        }
    }
    static string SingleLineCommentChars(GetName g)
    {
        return "ES6.SingleLineCommentChars";
    }

    static TParseTree SingleLineCommentChar(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.SingleLineCommentChar")(p);
        }
        else
        {
            if(auto m = tuple(`SingleLineCommentChar`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.SingleLineCommentChar"), "SingleLineCommentChar")(p);
                memo[tuple(`SingleLineCommentChar`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleLineCommentChar(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.SingleLineCommentChar")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.SingleLineCommentChar"), "SingleLineCommentChar")(TParseTree("", false,[], s));
        }
    }
    static string SingleLineCommentChar(GetName g)
    {
        return "ES6.SingleLineCommentChar";
    }

    static TParseTree CommonToken(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(IdentifierName, Punctuator, NumericLiteral, StringLiteral, Template), "ES6.CommonToken")(p);
        }
        else
        {
            if(auto m = tuple(`CommonToken`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(IdentifierName, Punctuator, NumericLiteral, StringLiteral, Template), "ES6.CommonToken"), "CommonToken")(p);
                memo[tuple(`CommonToken`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CommonToken(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(IdentifierName, Punctuator, NumericLiteral, StringLiteral, Template), "ES6.CommonToken")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(IdentifierName, Punctuator, NumericLiteral, StringLiteral, Template), "ES6.CommonToken"), "CommonToken")(TParseTree("", false,[], s));
        }
    }
    static string CommonToken(GetName g)
    {
        return "ES6.CommonToken";
    }

    static TParseTree IdentifierName(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(IdentifierStart, pegged.peg.zeroOrMore!(IdentifierPart))), "ES6.IdentifierName")(p);
        }
        else
        {
            if(auto m = tuple(`IdentifierName`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(IdentifierStart, pegged.peg.zeroOrMore!(IdentifierPart))), "ES6.IdentifierName"), "IdentifierName")(p);
                memo[tuple(`IdentifierName`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IdentifierName(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(IdentifierStart, pegged.peg.zeroOrMore!(IdentifierPart))), "ES6.IdentifierName")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(IdentifierStart, pegged.peg.zeroOrMore!(IdentifierPart))), "ES6.IdentifierName"), "IdentifierName")(TParseTree("", false,[], s));
        }
    }
    static string IdentifierName(GetName g)
    {
        return "ES6.IdentifierName";
    }

    static TParseTree IdentifierStart(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDStart, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence))), "ES6.IdentifierStart")(p);
        }
        else
        {
            if(auto m = tuple(`IdentifierStart`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDStart, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence))), "ES6.IdentifierStart"), "IdentifierStart")(p);
                memo[tuple(`IdentifierStart`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IdentifierStart(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDStart, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence))), "ES6.IdentifierStart")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDStart, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence))), "ES6.IdentifierStart"), "IdentifierStart")(TParseTree("", false,[], s));
        }
    }
    static string IdentifierStart(GetName g)
    {
        return "ES6.IdentifierStart";
    }

    static TParseTree IdentifierPart(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDContinue, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence), pegged.peg.literal!("\u200C"), pegged.peg.literal!("\u200D"))), "ES6.IdentifierPart")(p);
        }
        else
        {
            if(auto m = tuple(`IdentifierPart`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDContinue, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence), pegged.peg.literal!("\u200C"), pegged.peg.literal!("\u200D"))), "ES6.IdentifierPart"), "IdentifierPart")(p);
                memo[tuple(`IdentifierPart`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IdentifierPart(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDContinue, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence), pegged.peg.literal!("\u200C"), pegged.peg.literal!("\u200D"))), "ES6.IdentifierPart")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(UnicodeIDContinue, pegged.peg.literal!("$"), pegged.peg.literal!("_"), pegged.peg.and!(pegged.peg.literal!("\\"), UnicodeEscapeSequence), pegged.peg.literal!("\u200C"), pegged.peg.literal!("\u200D"))), "ES6.IdentifierPart"), "IdentifierPart")(TParseTree("", false,[], s));
        }
    }
    static string IdentifierPart(GetName g)
    {
        return "ES6.IdentifierPart";
    }

    static TParseTree UnicodeIDStart(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(ID_Start, Other_ID_Start)), "ES6.UnicodeIDStart")(p);
        }
        else
        {
            if(auto m = tuple(`UnicodeIDStart`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(ID_Start, Other_ID_Start)), "ES6.UnicodeIDStart"), "UnicodeIDStart")(p);
                memo[tuple(`UnicodeIDStart`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree UnicodeIDStart(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(ID_Start, Other_ID_Start)), "ES6.UnicodeIDStart")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(ID_Start, Other_ID_Start)), "ES6.UnicodeIDStart"), "UnicodeIDStart")(TParseTree("", false,[], s));
        }
    }
    static string UnicodeIDStart(GetName g)
    {
        return "ES6.UnicodeIDStart";
    }

    static TParseTree ID_Start(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Start")(p);
        }
        else
        {
            if(auto m = tuple(`ID_Start`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Start"), "ID_Start")(p);
                memo[tuple(`ID_Start`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ID_Start(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Start")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Start"), "ID_Start")(TParseTree("", false,[], s));
        }
    }
    static string ID_Start(GetName g)
    {
        return "ES6.ID_Start";
    }

    static TParseTree Other_ID_Start(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u2118"), pegged.peg.literal!("\u212e"), pegged.peg.charRange!('\u309b', '\u309c')), "ES6.Other_ID_Start")(p);
        }
        else
        {
            if(auto m = tuple(`Other_ID_Start`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u2118"), pegged.peg.literal!("\u212e"), pegged.peg.charRange!('\u309b', '\u309c')), "ES6.Other_ID_Start"), "Other_ID_Start")(p);
                memo[tuple(`Other_ID_Start`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Other_ID_Start(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u2118"), pegged.peg.literal!("\u212e"), pegged.peg.charRange!('\u309b', '\u309c')), "ES6.Other_ID_Start")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u2118"), pegged.peg.literal!("\u212e"), pegged.peg.charRange!('\u309b', '\u309c')), "ES6.Other_ID_Start"), "Other_ID_Start")(TParseTree("", false,[], s));
        }
    }
    static string Other_ID_Start(GetName g)
    {
        return "ES6.Other_ID_Start";
    }

    static TParseTree UnicodeIDContinue(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(ID_Continue, Other_ID_Continue, Other_ID_Start), "ES6.UnicodeIDContinue")(p);
        }
        else
        {
            if(auto m = tuple(`UnicodeIDContinue`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(ID_Continue, Other_ID_Continue, Other_ID_Start), "ES6.UnicodeIDContinue"), "UnicodeIDContinue")(p);
                memo[tuple(`UnicodeIDContinue`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree UnicodeIDContinue(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(ID_Continue, Other_ID_Continue, Other_ID_Start), "ES6.UnicodeIDContinue")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(ID_Continue, Other_ID_Continue, Other_ID_Start), "ES6.UnicodeIDContinue"), "UnicodeIDContinue")(TParseTree("", false,[], s));
        }
    }
    static string UnicodeIDContinue(GetName g)
    {
        return "ES6.UnicodeIDContinue";
    }

    static TParseTree ID_Continue(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0030', '\u0039'), pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.literal!("\u005f"), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Continue")(p);
        }
        else
        {
            if(auto m = tuple(`ID_Continue`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0030', '\u0039'), pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.literal!("\u005f"), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Continue"), "ID_Continue")(p);
                memo[tuple(`ID_Continue`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ID_Continue(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0030', '\u0039'), pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.literal!("\u005f"), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Continue")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('\u0030', '\u0039'), pegged.peg.charRange!('\u0041', '\u005a'), pegged.peg.literal!("\u005f"), pegged.peg.charRange!('\u0061', '\u007a'), pegged.peg.literal!("\u00aa"), pegged.peg.literal!("\u00b5"), pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u00ba"), pegged.peg.charRange!('\u00c0', '\u00d6'), pegged.peg.charRange!('\u00d8', '\u00f6')), "ES6.ID_Continue"), "ID_Continue")(TParseTree("", false,[], s));
        }
    }
    static string ID_Continue(GetName g)
    {
        return "ES6.ID_Continue";
    }

    static TParseTree Other_ID_Continue(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u0387"), pegged.peg.charRange!('\u1369', '\u1371'), pegged.peg.literal!("\u19da")), "ES6.Other_ID_Continue")(p);
        }
        else
        {
            if(auto m = tuple(`Other_ID_Continue`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u0387"), pegged.peg.charRange!('\u1369', '\u1371'), pegged.peg.literal!("\u19da")), "ES6.Other_ID_Continue"), "Other_ID_Continue")(p);
                memo[tuple(`Other_ID_Continue`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Other_ID_Continue(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u0387"), pegged.peg.charRange!('\u1369', '\u1371'), pegged.peg.literal!("\u19da")), "ES6.Other_ID_Continue")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("\u00b7"), pegged.peg.literal!("\u0387"), pegged.peg.charRange!('\u1369', '\u1371'), pegged.peg.literal!("\u19da")), "ES6.Other_ID_Continue"), "Other_ID_Continue")(TParseTree("", false,[], s));
        }
    }
    static string Other_ID_Continue(GetName g)
    {
        return "ES6.Other_ID_Continue";
    }

    static TParseTree ReservedWord(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(Keyword, FutureReservedWord, NullLiteral, BooleanLiteral), "ES6.ReservedWord")(p);
        }
        else
        {
            if(auto m = tuple(`ReservedWord`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(Keyword, FutureReservedWord, NullLiteral, BooleanLiteral), "ES6.ReservedWord"), "ReservedWord")(p);
                memo[tuple(`ReservedWord`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ReservedWord(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(Keyword, FutureReservedWord, NullLiteral, BooleanLiteral), "ES6.ReservedWord")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(Keyword, FutureReservedWord, NullLiteral, BooleanLiteral), "ES6.ReservedWord"), "ReservedWord")(TParseTree("", false,[], s));
        }
    }
    static string ReservedWord(GetName g)
    {
        return "ES6.ReservedWord";
    }

    static TParseTree Keyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("break", "do", "in", "typeof", "case", "else", "instanceof", "var", "catch", "export", "new", "void", "class", "extends", "return", "while", "const", "finally", "super", "with", "continue", "for", "switch", "yield", "debugger", "function", "this", "default", "if", "throw", "delete", "import", "try"), "ES6.Keyword")(p);
        }
        else
        {
            if(auto m = tuple(`Keyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("break", "do", "in", "typeof", "case", "else", "instanceof", "var", "catch", "export", "new", "void", "class", "extends", "return", "while", "const", "finally", "super", "with", "continue", "for", "switch", "yield", "debugger", "function", "this", "default", "if", "throw", "delete", "import", "try"), "ES6.Keyword"), "Keyword")(p);
                memo[tuple(`Keyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Keyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("break", "do", "in", "typeof", "case", "else", "instanceof", "var", "catch", "export", "new", "void", "class", "extends", "return", "while", "const", "finally", "super", "with", "continue", "for", "switch", "yield", "debugger", "function", "this", "default", "if", "throw", "delete", "import", "try"), "ES6.Keyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("break", "do", "in", "typeof", "case", "else", "instanceof", "var", "catch", "export", "new", "void", "class", "extends", "return", "while", "const", "finally", "super", "with", "continue", "for", "switch", "yield", "debugger", "function", "this", "default", "if", "throw", "delete", "import", "try"), "ES6.Keyword"), "Keyword")(TParseTree("", false,[], s));
        }
    }
    static string Keyword(GetName g)
    {
        return "ES6.Keyword";
    }

    static TParseTree FutureReservedWord(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("enum", "await"), "ES6.FutureReservedWord")(p);
        }
        else
        {
            if(auto m = tuple(`FutureReservedWord`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("enum", "await"), "ES6.FutureReservedWord"), "FutureReservedWord")(p);
                memo[tuple(`FutureReservedWord`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FutureReservedWord(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("enum", "await"), "ES6.FutureReservedWord")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("enum", "await"), "ES6.FutureReservedWord"), "FutureReservedWord")(TParseTree("", false,[], s));
        }
    }
    static string FutureReservedWord(GetName g)
    {
        return "ES6.FutureReservedWord";
    }

    static TParseTree Punctuator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("{", "}", "(", ")", "[", "]", ".", ";", ",", "<=", ">=", "<", ">", "===", "!==", "==", "!=", "++", "--", "*=", "*", "%=", "%", "+=", "+", "-=", "-", "<<=", "<<", ">>>=", ">>>", ">>=", ">>", "&&", "||", "^=", "^", "!", "~", "&=", "&", "|=", "|", "?", ":", "=>", "="), "ES6.Punctuator")(p);
        }
        else
        {
            if(auto m = tuple(`Punctuator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("{", "}", "(", ")", "[", "]", ".", ";", ",", "<=", ">=", "<", ">", "===", "!==", "==", "!=", "++", "--", "*=", "*", "%=", "%", "+=", "+", "-=", "-", "<<=", "<<", ">>>=", ">>>", ">>=", ">>", "&&", "||", "^=", "^", "!", "~", "&=", "&", "|=", "|", "?", ":", "=>", "="), "ES6.Punctuator"), "Punctuator")(p);
                memo[tuple(`Punctuator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Punctuator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("{", "}", "(", ")", "[", "]", ".", ";", ",", "<=", ">=", "<", ">", "===", "!==", "==", "!=", "++", "--", "*=", "*", "%=", "%", "+=", "+", "-=", "-", "<<=", "<<", ">>>=", ">>>", ">>=", ">>", "&&", "||", "^=", "^", "!", "~", "&=", "&", "|=", "|", "?", ":", "=>", "="), "ES6.Punctuator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("{", "}", "(", ")", "[", "]", ".", ";", ",", "<=", ">=", "<", ">", "===", "!==", "==", "!=", "++", "--", "*=", "*", "%=", "%", "+=", "+", "-=", "-", "<<=", "<<", ">>>=", ">>>", ">>=", ">>", "&&", "||", "^=", "^", "!", "~", "&=", "&", "|=", "|", "?", ":", "=>", "="), "ES6.Punctuator"), "Punctuator")(TParseTree("", false,[], s));
        }
    }
    static string Punctuator(GetName g)
    {
        return "ES6.Punctuator";
    }

    static TParseTree DivPunctuator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("/=", "/"), "ES6.DivPunctuator")(p);
        }
        else
        {
            if(auto m = tuple(`DivPunctuator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("/=", "/"), "ES6.DivPunctuator"), "DivPunctuator")(p);
                memo[tuple(`DivPunctuator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DivPunctuator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("/=", "/"), "ES6.DivPunctuator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("/=", "/"), "ES6.DivPunctuator"), "DivPunctuator")(TParseTree("", false,[], s));
        }
    }
    static string DivPunctuator(GetName g)
    {
        return "ES6.DivPunctuator";
    }

    static TParseTree RightBracePunctuator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.literal!("}"), "ES6.RightBracePunctuator")(p);
        }
        else
        {
            if(auto m = tuple(`RightBracePunctuator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.literal!("}"), "ES6.RightBracePunctuator"), "RightBracePunctuator")(p);
                memo[tuple(`RightBracePunctuator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RightBracePunctuator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.literal!("}"), "ES6.RightBracePunctuator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.literal!("}"), "ES6.RightBracePunctuator"), "RightBracePunctuator")(TParseTree("", false,[], s));
        }
    }
    static string RightBracePunctuator(GetName g)
    {
        return "ES6.RightBracePunctuator";
    }

    static TParseTree NullLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.literal!("null"), "ES6.NullLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`NullLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.literal!("null"), "ES6.NullLiteral"), "NullLiteral")(p);
                memo[tuple(`NullLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NullLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.literal!("null"), "ES6.NullLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.literal!("null"), "ES6.NullLiteral"), "NullLiteral")(TParseTree("", false,[], s));
        }
    }
    static string NullLiteral(GetName g)
    {
        return "ES6.NullLiteral";
    }

    static TParseTree BooleanLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("true", "false"), "ES6.BooleanLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`BooleanLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("true", "false"), "ES6.BooleanLiteral"), "BooleanLiteral")(p);
                memo[tuple(`BooleanLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BooleanLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("true", "false"), "ES6.BooleanLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("true", "false"), "ES6.BooleanLiteral"), "BooleanLiteral")(TParseTree("", false,[], s));
        }
    }
    static string BooleanLiteral(GetName g)
    {
        return "ES6.BooleanLiteral";
    }

    static TParseTree NumericLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(HexIntegerLiteral, DecimalLiteral, BinaryIntegerLiteral, OctalIntegerLiteral), "ES6.NumericLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`NumericLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(HexIntegerLiteral, DecimalLiteral, BinaryIntegerLiteral, OctalIntegerLiteral), "ES6.NumericLiteral"), "NumericLiteral")(p);
                memo[tuple(`NumericLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NumericLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(HexIntegerLiteral, DecimalLiteral, BinaryIntegerLiteral, OctalIntegerLiteral), "ES6.NumericLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(HexIntegerLiteral, DecimalLiteral, BinaryIntegerLiteral, OctalIntegerLiteral), "ES6.NumericLiteral"), "NumericLiteral")(TParseTree("", false,[], s));
        }
    }
    static string NumericLiteral(GetName g)
    {
        return "ES6.NumericLiteral";
    }

    static TParseTree DecimalLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(DecimalIntegerLiteral, pegged.peg.option!(pegged.peg.and!(pegged.peg.literal!("."), pegged.peg.option!(DecimalDigits))), pegged.peg.option!(ExponentPart)), pegged.peg.and!(pegged.peg.literal!("."), DecimalDigits, pegged.peg.option!(ExponentPart)))), "ES6.DecimalLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`DecimalLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(DecimalIntegerLiteral, pegged.peg.option!(pegged.peg.and!(pegged.peg.literal!("."), pegged.peg.option!(DecimalDigits))), pegged.peg.option!(ExponentPart)), pegged.peg.and!(pegged.peg.literal!("."), DecimalDigits, pegged.peg.option!(ExponentPart)))), "ES6.DecimalLiteral"), "DecimalLiteral")(p);
                memo[tuple(`DecimalLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DecimalLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(DecimalIntegerLiteral, pegged.peg.option!(pegged.peg.and!(pegged.peg.literal!("."), pegged.peg.option!(DecimalDigits))), pegged.peg.option!(ExponentPart)), pegged.peg.and!(pegged.peg.literal!("."), DecimalDigits, pegged.peg.option!(ExponentPart)))), "ES6.DecimalLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(DecimalIntegerLiteral, pegged.peg.option!(pegged.peg.and!(pegged.peg.literal!("."), pegged.peg.option!(DecimalDigits))), pegged.peg.option!(ExponentPart)), pegged.peg.and!(pegged.peg.literal!("."), DecimalDigits, pegged.peg.option!(ExponentPart)))), "ES6.DecimalLiteral"), "DecimalLiteral")(TParseTree("", false,[], s));
        }
    }
    static string DecimalLiteral(GetName g)
    {
        return "ES6.DecimalLiteral";
    }

    static TParseTree DecimalIntegerLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("0"), pegged.peg.and!(NonZeroDigit, pegged.peg.option!(DecimalDigits))), "ES6.DecimalIntegerLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`DecimalIntegerLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("0"), pegged.peg.and!(NonZeroDigit, pegged.peg.option!(DecimalDigits))), "ES6.DecimalIntegerLiteral"), "DecimalIntegerLiteral")(p);
                memo[tuple(`DecimalIntegerLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DecimalIntegerLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("0"), pegged.peg.and!(NonZeroDigit, pegged.peg.option!(DecimalDigits))), "ES6.DecimalIntegerLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.literal!("0"), pegged.peg.and!(NonZeroDigit, pegged.peg.option!(DecimalDigits))), "ES6.DecimalIntegerLiteral"), "DecimalIntegerLiteral")(TParseTree("", false,[], s));
        }
    }
    static string DecimalIntegerLiteral(GetName g)
    {
        return "ES6.DecimalIntegerLiteral";
    }

    static TParseTree DecimalDigits(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(DecimalDigit)), "ES6.DecimalDigits")(p);
        }
        else
        {
            if(auto m = tuple(`DecimalDigits`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(DecimalDigit)), "ES6.DecimalDigits"), "DecimalDigits")(p);
                memo[tuple(`DecimalDigits`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DecimalDigits(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(DecimalDigit)), "ES6.DecimalDigits")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(DecimalDigit)), "ES6.DecimalDigits"), "DecimalDigits")(TParseTree("", false,[], s));
        }
    }
    static string DecimalDigits(GetName g)
    {
        return "ES6.DecimalDigits";
    }

    static TParseTree DecimalDigit(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('0', '9'), "ES6.DecimalDigit")(p);
        }
        else
        {
            if(auto m = tuple(`DecimalDigit`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.charRange!('0', '9'), "ES6.DecimalDigit"), "DecimalDigit")(p);
                memo[tuple(`DecimalDigit`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DecimalDigit(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('0', '9'), "ES6.DecimalDigit")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.charRange!('0', '9'), "ES6.DecimalDigit"), "DecimalDigit")(TParseTree("", false,[], s));
        }
    }
    static string DecimalDigit(GetName g)
    {
        return "ES6.DecimalDigit";
    }

    static TParseTree NonZeroDigit(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('1', '9'), "ES6.NonZeroDigit")(p);
        }
        else
        {
            if(auto m = tuple(`NonZeroDigit`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.charRange!('1', '9'), "ES6.NonZeroDigit"), "NonZeroDigit")(p);
                memo[tuple(`NonZeroDigit`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NonZeroDigit(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('1', '9'), "ES6.NonZeroDigit")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.charRange!('1', '9'), "ES6.NonZeroDigit"), "NonZeroDigit")(TParseTree("", false,[], s));
        }
    }
    static string NonZeroDigit(GetName g)
    {
        return "ES6.NonZeroDigit";
    }

    static TParseTree ExponentPart(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ExponentIndicator, SignedInteger), "ES6.ExponentPart")(p);
        }
        else
        {
            if(auto m = tuple(`ExponentPart`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(ExponentIndicator, SignedInteger), "ES6.ExponentPart"), "ExponentPart")(p);
                memo[tuple(`ExponentPart`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExponentPart(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ExponentIndicator, SignedInteger), "ES6.ExponentPart")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(ExponentIndicator, SignedInteger), "ES6.ExponentPart"), "ExponentPart")(TParseTree("", false,[], s));
        }
    }
    static string ExponentPart(GetName g)
    {
        return "ES6.ExponentPart";
    }

    static TParseTree ExponentIndicator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("e", "E"), "ES6.ExponentIndicator")(p);
        }
        else
        {
            if(auto m = tuple(`ExponentIndicator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("e", "E"), "ES6.ExponentIndicator"), "ExponentIndicator")(p);
                memo[tuple(`ExponentIndicator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExponentIndicator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("e", "E"), "ES6.ExponentIndicator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("e", "E"), "ES6.ExponentIndicator"), "ExponentIndicator")(TParseTree("", false,[], s));
        }
    }
    static string ExponentIndicator(GetName g)
    {
        return "ES6.ExponentIndicator";
    }

    static TParseTree SignedInteger(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.keywords!("+", "-")), DecimalDigits), "ES6.SignedInteger")(p);
        }
        else
        {
            if(auto m = tuple(`SignedInteger`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.keywords!("+", "-")), DecimalDigits), "ES6.SignedInteger"), "SignedInteger")(p);
                memo[tuple(`SignedInteger`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SignedInteger(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.keywords!("+", "-")), DecimalDigits), "ES6.SignedInteger")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.keywords!("+", "-")), DecimalDigits), "ES6.SignedInteger"), "SignedInteger")(TParseTree("", false,[], s));
        }
    }
    static string SignedInteger(GetName g)
    {
        return "ES6.SignedInteger";
    }

    static TParseTree BinaryIntegerLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0b", "0B"), BinaryDigits)), "ES6.BinaryIntegerLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryIntegerLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0b", "0B"), BinaryDigits)), "ES6.BinaryIntegerLiteral"), "BinaryIntegerLiteral")(p);
                memo[tuple(`BinaryIntegerLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryIntegerLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0b", "0B"), BinaryDigits)), "ES6.BinaryIntegerLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0b", "0B"), BinaryDigits)), "ES6.BinaryIntegerLiteral"), "BinaryIntegerLiteral")(TParseTree("", false,[], s));
        }
    }
    static string BinaryIntegerLiteral(GetName g)
    {
        return "ES6.BinaryIntegerLiteral";
    }

    static TParseTree BinaryDigits(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(BinaryDigit)), "ES6.BinaryDigits")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryDigits`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(BinaryDigit)), "ES6.BinaryDigits"), "BinaryDigits")(p);
                memo[tuple(`BinaryDigits`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryDigits(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(BinaryDigit)), "ES6.BinaryDigits")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(BinaryDigit)), "ES6.BinaryDigits"), "BinaryDigits")(TParseTree("", false,[], s));
        }
    }
    static string BinaryDigits(GetName g)
    {
        return "ES6.BinaryDigits";
    }

    static TParseTree BinaryDigit(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("0", "1"), "ES6.BinaryDigit")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryDigit`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("0", "1"), "ES6.BinaryDigit"), "BinaryDigit")(p);
                memo[tuple(`BinaryDigit`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryDigit(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("0", "1"), "ES6.BinaryDigit")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("0", "1"), "ES6.BinaryDigit"), "BinaryDigit")(TParseTree("", false,[], s));
        }
    }
    static string BinaryDigit(GetName g)
    {
        return "ES6.BinaryDigit";
    }

    static TParseTree OctalIntegerLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0o", "0O"), OctalDigits)), "ES6.OctalIntegerLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`OctalIntegerLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0o", "0O"), OctalDigits)), "ES6.OctalIntegerLiteral"), "OctalIntegerLiteral")(p);
                memo[tuple(`OctalIntegerLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree OctalIntegerLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0o", "0O"), OctalDigits)), "ES6.OctalIntegerLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0o", "0O"), OctalDigits)), "ES6.OctalIntegerLiteral"), "OctalIntegerLiteral")(TParseTree("", false,[], s));
        }
    }
    static string OctalIntegerLiteral(GetName g)
    {
        return "ES6.OctalIntegerLiteral";
    }

    static TParseTree OctalDigits(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(OctalDigit), "ES6.OctalDigits")(p);
        }
        else
        {
            if(auto m = tuple(`OctalDigits`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(OctalDigit), "ES6.OctalDigits"), "OctalDigits")(p);
                memo[tuple(`OctalDigits`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree OctalDigits(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(OctalDigit), "ES6.OctalDigits")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(OctalDigit), "ES6.OctalDigits"), "OctalDigits")(TParseTree("", false,[], s));
        }
    }
    static string OctalDigits(GetName g)
    {
        return "ES6.OctalDigits";
    }

    static TParseTree OctalDigit(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('0', '7'), "ES6.OctalDigit")(p);
        }
        else
        {
            if(auto m = tuple(`OctalDigit`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.charRange!('0', '7'), "ES6.OctalDigit"), "OctalDigit")(p);
                memo[tuple(`OctalDigit`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree OctalDigit(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.charRange!('0', '7'), "ES6.OctalDigit")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.charRange!('0', '7'), "ES6.OctalDigit"), "OctalDigit")(TParseTree("", false,[], s));
        }
    }
    static string OctalDigit(GetName g)
    {
        return "ES6.OctalDigit";
    }

    static TParseTree HexIntegerLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0x", "0X"), HexDigits)), "ES6.HexIntegerLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`HexIntegerLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0x", "0X"), HexDigits)), "ES6.HexIntegerLiteral"), "HexIntegerLiteral")(p);
                memo[tuple(`HexIntegerLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HexIntegerLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0x", "0X"), HexDigits)), "ES6.HexIntegerLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.keywords!("0x", "0X"), HexDigits)), "ES6.HexIntegerLiteral"), "HexIntegerLiteral")(TParseTree("", false,[], s));
        }
    }
    static string HexIntegerLiteral(GetName g)
    {
        return "ES6.HexIntegerLiteral";
    }

    static TParseTree HexDigits(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(HexDigit), "ES6.HexDigits")(p);
        }
        else
        {
            if(auto m = tuple(`HexDigits`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(HexDigit), "ES6.HexDigits"), "HexDigits")(p);
                memo[tuple(`HexDigits`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HexDigits(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(HexDigit), "ES6.HexDigits")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(HexDigit), "ES6.HexDigits"), "HexDigits")(TParseTree("", false,[], s));
        }
    }
    static string HexDigits(GetName g)
    {
        return "ES6.HexDigits";
    }

    static TParseTree HexDigit(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('0', '9'), pegged.peg.charRange!('a', 'f'), pegged.peg.charRange!('A', 'F')), "ES6.HexDigit")(p);
        }
        else
        {
            if(auto m = tuple(`HexDigit`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('0', '9'), pegged.peg.charRange!('a', 'f'), pegged.peg.charRange!('A', 'F')), "ES6.HexDigit"), "HexDigit")(p);
                memo[tuple(`HexDigit`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HexDigit(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('0', '9'), pegged.peg.charRange!('a', 'f'), pegged.peg.charRange!('A', 'F')), "ES6.HexDigit")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.charRange!('0', '9'), pegged.peg.charRange!('a', 'f'), pegged.peg.charRange!('A', 'F')), "ES6.HexDigit"), "HexDigit")(TParseTree("", false,[], s));
        }
    }
    static string HexDigit(GetName g)
    {
        return "ES6.HexDigit";
    }

    static TParseTree StringLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("\""), pegged.peg.option!(DoubleStringCharacters), pegged.peg.literal!("\"")), pegged.peg.and!(pegged.peg.literal!("'"), pegged.peg.option!(SingleStringCharacters), pegged.peg.literal!("'")))), "ES6.StringLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`StringLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("\""), pegged.peg.option!(DoubleStringCharacters), pegged.peg.literal!("\"")), pegged.peg.and!(pegged.peg.literal!("'"), pegged.peg.option!(SingleStringCharacters), pegged.peg.literal!("'")))), "ES6.StringLiteral"), "StringLiteral")(p);
                memo[tuple(`StringLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StringLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("\""), pegged.peg.option!(DoubleStringCharacters), pegged.peg.literal!("\"")), pegged.peg.and!(pegged.peg.literal!("'"), pegged.peg.option!(SingleStringCharacters), pegged.peg.literal!("'")))), "ES6.StringLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("\""), pegged.peg.option!(DoubleStringCharacters), pegged.peg.literal!("\"")), pegged.peg.and!(pegged.peg.literal!("'"), pegged.peg.option!(SingleStringCharacters), pegged.peg.literal!("'")))), "ES6.StringLiteral"), "StringLiteral")(TParseTree("", false,[], s));
        }
    }
    static string StringLiteral(GetName g)
    {
        return "ES6.StringLiteral";
    }

    static TParseTree DoubleStringCharacters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(DoubleStringCharacter), "ES6.DoubleStringCharacters")(p);
        }
        else
        {
            if(auto m = tuple(`DoubleStringCharacters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(DoubleStringCharacter), "ES6.DoubleStringCharacters"), "DoubleStringCharacters")(p);
                memo[tuple(`DoubleStringCharacters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DoubleStringCharacters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(DoubleStringCharacter), "ES6.DoubleStringCharacters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(DoubleStringCharacter), "ES6.DoubleStringCharacters"), "DoubleStringCharacters")(TParseTree("", false,[], s));
        }
    }
    static string DoubleStringCharacters(GetName g)
    {
        return "ES6.DoubleStringCharacters";
    }

    static TParseTree SingleStringCharacters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(SingleStringCharacter), "ES6.SingleStringCharacters")(p);
        }
        else
        {
            if(auto m = tuple(`SingleStringCharacters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(SingleStringCharacter), "ES6.SingleStringCharacters"), "SingleStringCharacters")(p);
                memo[tuple(`SingleStringCharacters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleStringCharacters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(SingleStringCharacter), "ES6.SingleStringCharacters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(SingleStringCharacter), "ES6.SingleStringCharacters"), "SingleStringCharacters")(TParseTree("", false,[], s));
        }
    }
    static string SingleStringCharacters(GetName g)
    {
        return "ES6.SingleStringCharacters";
    }

    static TParseTree DoubleStringCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\""), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.DoubleStringCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`DoubleStringCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\""), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.DoubleStringCharacter"), "DoubleStringCharacter")(p);
                memo[tuple(`DoubleStringCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DoubleStringCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\""), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.DoubleStringCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\""), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.DoubleStringCharacter"), "DoubleStringCharacter")(TParseTree("", false,[], s));
        }
    }
    static string DoubleStringCharacter(GetName g)
    {
        return "ES6.DoubleStringCharacter";
    }

    static TParseTree SingleStringCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\'"), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.SingleStringCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`SingleStringCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\'"), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.SingleStringCharacter"), "SingleStringCharacter")(p);
                memo[tuple(`SingleStringCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleStringCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\'"), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.SingleStringCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\'"), pegged.peg.literal!("\\"), LineTerminator)), SourceCharacter), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation), "ES6.SingleStringCharacter"), "SingleStringCharacter")(TParseTree("", false,[], s));
        }
    }
    static string SingleStringCharacter(GetName g)
    {
        return "ES6.SingleStringCharacter";
    }

    static TParseTree LineContinuation(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), LineTerminatorSequence), "ES6.LineContinuation")(p);
        }
        else
        {
            if(auto m = tuple(`LineContinuation`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), LineTerminatorSequence), "ES6.LineContinuation"), "LineContinuation")(p);
                memo[tuple(`LineContinuation`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LineContinuation(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), LineTerminatorSequence), "ES6.LineContinuation")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), LineTerminatorSequence), "ES6.LineContinuation"), "LineContinuation")(TParseTree("", false,[], s));
        }
    }
    static string LineContinuation(GetName g)
    {
        return "ES6.LineContinuation";
    }

    static TParseTree EscapeSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.or!(CharacterEscapeSequence, pegged.peg.and!(pegged.peg.literal!("0"), pegged.peg.negLookahead!(DecimalDigit))), HexEscapeSequence, UnicodeEscapeSequence), "ES6.EscapeSequence")(p);
        }
        else
        {
            if(auto m = tuple(`EscapeSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.or!(CharacterEscapeSequence, pegged.peg.and!(pegged.peg.literal!("0"), pegged.peg.negLookahead!(DecimalDigit))), HexEscapeSequence, UnicodeEscapeSequence), "ES6.EscapeSequence"), "EscapeSequence")(p);
                memo[tuple(`EscapeSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree EscapeSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.or!(CharacterEscapeSequence, pegged.peg.and!(pegged.peg.literal!("0"), pegged.peg.negLookahead!(DecimalDigit))), HexEscapeSequence, UnicodeEscapeSequence), "ES6.EscapeSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.or!(CharacterEscapeSequence, pegged.peg.and!(pegged.peg.literal!("0"), pegged.peg.negLookahead!(DecimalDigit))), HexEscapeSequence, UnicodeEscapeSequence), "ES6.EscapeSequence"), "EscapeSequence")(TParseTree("", false,[], s));
        }
    }
    static string EscapeSequence(GetName g)
    {
        return "ES6.EscapeSequence";
    }

    static TParseTree CharacterEscapeSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, NonEscapeCharacter), "ES6.CharacterEscapeSequence")(p);
        }
        else
        {
            if(auto m = tuple(`CharacterEscapeSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, NonEscapeCharacter), "ES6.CharacterEscapeSequence"), "CharacterEscapeSequence")(p);
                memo[tuple(`CharacterEscapeSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CharacterEscapeSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, NonEscapeCharacter), "ES6.CharacterEscapeSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, NonEscapeCharacter), "ES6.CharacterEscapeSequence"), "CharacterEscapeSequence")(TParseTree("", false,[], s));
        }
    }
    static string CharacterEscapeSequence(GetName g)
    {
        return "ES6.CharacterEscapeSequence";
    }

    static TParseTree SingleEscapeCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("'", "\"", "\\", "b", "f", "n", "r", "t", "v"), "ES6.SingleEscapeCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`SingleEscapeCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("'", "\"", "\\", "b", "f", "n", "r", "t", "v"), "ES6.SingleEscapeCharacter"), "SingleEscapeCharacter")(p);
                memo[tuple(`SingleEscapeCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleEscapeCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("'", "\"", "\\", "b", "f", "n", "r", "t", "v"), "ES6.SingleEscapeCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("'", "\"", "\\", "b", "f", "n", "r", "t", "v"), "ES6.SingleEscapeCharacter"), "SingleEscapeCharacter")(TParseTree("", false,[], s));
        }
    }
    static string SingleEscapeCharacter(GetName g)
    {
        return "ES6.SingleEscapeCharacter";
    }

    static TParseTree NonEscapeCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(EscapeCharacter, LineTerminator)), SourceCharacter), "ES6.NonEscapeCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`NonEscapeCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(EscapeCharacter, LineTerminator)), SourceCharacter), "ES6.NonEscapeCharacter"), "NonEscapeCharacter")(p);
                memo[tuple(`NonEscapeCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NonEscapeCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(EscapeCharacter, LineTerminator)), SourceCharacter), "ES6.NonEscapeCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(EscapeCharacter, LineTerminator)), SourceCharacter), "ES6.NonEscapeCharacter"), "NonEscapeCharacter")(TParseTree("", false,[], s));
        }
    }
    static string NonEscapeCharacter(GetName g)
    {
        return "ES6.NonEscapeCharacter";
    }

    static TParseTree EscapeCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, DecimalDigit, pegged.peg.literal!("x"), pegged.peg.literal!("u")), "ES6.EscapeCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`EscapeCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, DecimalDigit, pegged.peg.literal!("x"), pegged.peg.literal!("u")), "ES6.EscapeCharacter"), "EscapeCharacter")(p);
                memo[tuple(`EscapeCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree EscapeCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, DecimalDigit, pegged.peg.literal!("x"), pegged.peg.literal!("u")), "ES6.EscapeCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(SingleEscapeCharacter, DecimalDigit, pegged.peg.literal!("x"), pegged.peg.literal!("u")), "ES6.EscapeCharacter"), "EscapeCharacter")(TParseTree("", false,[], s));
        }
    }
    static string EscapeCharacter(GetName g)
    {
        return "ES6.EscapeCharacter";
    }

    static TParseTree HexEscapeSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("x"), HexDigit, HexDigit), "ES6.HexEscapeSequence")(p);
        }
        else
        {
            if(auto m = tuple(`HexEscapeSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("x"), HexDigit, HexDigit), "ES6.HexEscapeSequence"), "HexEscapeSequence")(p);
                memo[tuple(`HexEscapeSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HexEscapeSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("x"), HexDigit, HexDigit), "ES6.HexEscapeSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("x"), HexDigit, HexDigit), "ES6.HexEscapeSequence"), "HexEscapeSequence")(TParseTree("", false,[], s));
        }
    }
    static string HexEscapeSequence(GetName g)
    {
        return "ES6.HexEscapeSequence";
    }

    static TParseTree UnicodeEscapeSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("u"), Hex4Digits), pegged.peg.and!(pegged.peg.literal!("u{"), HexDigits, pegged.peg.literal!("}"))), "ES6.UnicodeEscapeSequence")(p);
        }
        else
        {
            if(auto m = tuple(`UnicodeEscapeSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("u"), Hex4Digits), pegged.peg.and!(pegged.peg.literal!("u{"), HexDigits, pegged.peg.literal!("}"))), "ES6.UnicodeEscapeSequence"), "UnicodeEscapeSequence")(p);
                memo[tuple(`UnicodeEscapeSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree UnicodeEscapeSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("u"), Hex4Digits), pegged.peg.and!(pegged.peg.literal!("u{"), HexDigits, pegged.peg.literal!("}"))), "ES6.UnicodeEscapeSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("u"), Hex4Digits), pegged.peg.and!(pegged.peg.literal!("u{"), HexDigits, pegged.peg.literal!("}"))), "ES6.UnicodeEscapeSequence"), "UnicodeEscapeSequence")(TParseTree("", false,[], s));
        }
    }
    static string UnicodeEscapeSequence(GetName g)
    {
        return "ES6.UnicodeEscapeSequence";
    }

    static TParseTree Hex4Digits(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(HexDigit, HexDigit, HexDigit, HexDigit), "ES6.Hex4Digits")(p);
        }
        else
        {
            if(auto m = tuple(`Hex4Digits`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(HexDigit, HexDigit, HexDigit, HexDigit), "ES6.Hex4Digits"), "Hex4Digits")(p);
                memo[tuple(`Hex4Digits`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Hex4Digits(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(HexDigit, HexDigit, HexDigit, HexDigit), "ES6.Hex4Digits")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(HexDigit, HexDigit, HexDigit, HexDigit), "ES6.Hex4Digits"), "Hex4Digits")(TParseTree("", false,[], s));
        }
    }
    static string Hex4Digits(GetName g)
    {
        return "ES6.Hex4Digits";
    }

    static TParseTree RegularExpressionLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("/"), RegularExpressionBody, pegged.peg.literal!("/"), RegularExpressionFlags), "ES6.RegularExpressionLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("/"), RegularExpressionBody, pegged.peg.literal!("/"), RegularExpressionFlags), "ES6.RegularExpressionLiteral"), "RegularExpressionLiteral")(p);
                memo[tuple(`RegularExpressionLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("/"), RegularExpressionBody, pegged.peg.literal!("/"), RegularExpressionFlags), "ES6.RegularExpressionLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("/"), RegularExpressionBody, pegged.peg.literal!("/"), RegularExpressionFlags), "ES6.RegularExpressionLiteral"), "RegularExpressionLiteral")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionLiteral(GetName g)
    {
        return "ES6.RegularExpressionLiteral";
    }

    static TParseTree RegularExpressionBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(RegularExpressionFirstChar, RegularExpressionChars), "ES6.RegularExpressionBody")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(RegularExpressionFirstChar, RegularExpressionChars), "ES6.RegularExpressionBody"), "RegularExpressionBody")(p);
                memo[tuple(`RegularExpressionBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(RegularExpressionFirstChar, RegularExpressionChars), "ES6.RegularExpressionBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(RegularExpressionFirstChar, RegularExpressionChars), "ES6.RegularExpressionBody"), "RegularExpressionBody")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionBody(GetName g)
    {
        return "ES6.RegularExpressionBody";
    }

    static TParseTree RegularExpressionChars(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionChar), "ES6.RegularExpressionChars")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionChars`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionChar), "ES6.RegularExpressionChars"), "RegularExpressionChars")(p);
                memo[tuple(`RegularExpressionChars`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionChars(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionChar), "ES6.RegularExpressionChars")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionChar), "ES6.RegularExpressionChars"), "RegularExpressionChars")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionChars(GetName g)
    {
        return "ES6.RegularExpressionChars";
    }

    static TParseTree RegularExpressionFirstChar(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("*", "\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionFirstChar")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionFirstChar`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("*", "\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionFirstChar"), "RegularExpressionFirstChar")(p);
                memo[tuple(`RegularExpressionFirstChar`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionFirstChar(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("*", "\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionFirstChar")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("*", "\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionFirstChar"), "RegularExpressionFirstChar")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionFirstChar(GetName g)
    {
        return "ES6.RegularExpressionFirstChar";
    }

    static TParseTree RegularExpressionChar(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionChar")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionChar`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionChar"), "RegularExpressionChar")(p);
                memo[tuple(`RegularExpressionChar`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionChar(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionChar")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("\\", "/", "[")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence, RegularExpressionClass), "ES6.RegularExpressionChar"), "RegularExpressionChar")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionChar(GetName g)
    {
        return "ES6.RegularExpressionChar";
    }

    static TParseTree RegularExpressionBackslashSequence(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), RegularExpressionNonTerminator), "ES6.RegularExpressionBackslashSequence")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionBackslashSequence`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), RegularExpressionNonTerminator), "ES6.RegularExpressionBackslashSequence"), "RegularExpressionBackslashSequence")(p);
                memo[tuple(`RegularExpressionBackslashSequence`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionBackslashSequence(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), RegularExpressionNonTerminator), "ES6.RegularExpressionBackslashSequence")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("\\"), RegularExpressionNonTerminator), "ES6.RegularExpressionBackslashSequence"), "RegularExpressionBackslashSequence")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionBackslashSequence(GetName g)
    {
        return "ES6.RegularExpressionBackslashSequence";
    }

    static TParseTree RegularExpressionNonTerminator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.RegularExpressionNonTerminator")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionNonTerminator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.RegularExpressionNonTerminator"), "RegularExpressionNonTerminator")(p);
                memo[tuple(`RegularExpressionNonTerminator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionNonTerminator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.RegularExpressionNonTerminator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(LineTerminator), SourceCharacter), "ES6.RegularExpressionNonTerminator"), "RegularExpressionNonTerminator")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionNonTerminator(GetName g)
    {
        return "ES6.RegularExpressionNonTerminator";
    }

    static TParseTree RegularExpressionClass(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("[")), RegularExpressionClassChars, pegged.peg.discard!(pegged.peg.literal!("]"))), "ES6.RegularExpressionClass")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionClass`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("[")), RegularExpressionClassChars, pegged.peg.discard!(pegged.peg.literal!("]"))), "ES6.RegularExpressionClass"), "RegularExpressionClass")(p);
                memo[tuple(`RegularExpressionClass`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionClass(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("[")), RegularExpressionClassChars, pegged.peg.discard!(pegged.peg.literal!("]"))), "ES6.RegularExpressionClass")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("[")), RegularExpressionClassChars, pegged.peg.discard!(pegged.peg.literal!("]"))), "ES6.RegularExpressionClass"), "RegularExpressionClass")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionClass(GetName g)
    {
        return "ES6.RegularExpressionClass";
    }

    static TParseTree RegularExpressionClassChars(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionClassChar), "ES6.RegularExpressionClassChars")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionClassChars`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionClassChar), "ES6.RegularExpressionClassChars"), "RegularExpressionClassChars")(p);
                memo[tuple(`RegularExpressionClassChars`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionClassChars(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionClassChar), "ES6.RegularExpressionClassChars")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(RegularExpressionClassChar), "ES6.RegularExpressionClassChars"), "RegularExpressionClassChars")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionClassChars(GetName g)
    {
        return "ES6.RegularExpressionClassChars";
    }

    static TParseTree RegularExpressionClassChar(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("]", "\\")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence), "ES6.RegularExpressionClassChar")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionClassChar`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("]", "\\")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence), "ES6.RegularExpressionClassChar"), "RegularExpressionClassChar")(p);
                memo[tuple(`RegularExpressionClassChar`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionClassChar(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("]", "\\")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence), "ES6.RegularExpressionClassChar")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("]", "\\")), RegularExpressionNonTerminator), RegularExpressionBackslashSequence), "ES6.RegularExpressionClassChar"), "RegularExpressionClassChar")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionClassChar(GetName g)
    {
        return "ES6.RegularExpressionClassChar";
    }

    static TParseTree RegularExpressionFlags(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(IdentifierPart), "ES6.RegularExpressionFlags")(p);
        }
        else
        {
            if(auto m = tuple(`RegularExpressionFlags`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(IdentifierPart), "ES6.RegularExpressionFlags"), "RegularExpressionFlags")(p);
                memo[tuple(`RegularExpressionFlags`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RegularExpressionFlags(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(IdentifierPart), "ES6.RegularExpressionFlags")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(IdentifierPart), "ES6.RegularExpressionFlags"), "RegularExpressionFlags")(TParseTree("", false,[], s));
        }
    }
    static string RegularExpressionFlags(GetName g)
    {
        return "ES6.RegularExpressionFlags";
    }

    static TParseTree Template(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(NoSubstitutionTemplate, TemplateHead), "ES6.Template")(p);
        }
        else
        {
            if(auto m = tuple(`Template`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(NoSubstitutionTemplate, TemplateHead), "ES6.Template"), "Template")(p);
                memo[tuple(`Template`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Template(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(NoSubstitutionTemplate, TemplateHead), "ES6.Template")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(NoSubstitutionTemplate, TemplateHead), "ES6.Template"), "Template")(TParseTree("", false,[], s));
        }
    }
    static string Template(GetName g)
    {
        return "ES6.Template";
    }

    static TParseTree NoSubstitutionTemplate(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.NoSubstitutionTemplate")(p);
        }
        else
        {
            if(auto m = tuple(`NoSubstitutionTemplate`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.NoSubstitutionTemplate"), "NoSubstitutionTemplate")(p);
                memo[tuple(`NoSubstitutionTemplate`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NoSubstitutionTemplate(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.NoSubstitutionTemplate")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.NoSubstitutionTemplate"), "NoSubstitutionTemplate")(TParseTree("", false,[], s));
        }
    }
    static string NoSubstitutionTemplate(GetName g)
    {
        return "ES6.NoSubstitutionTemplate";
    }

    static TParseTree TemplateHead(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateHead")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateHead`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateHead"), "TemplateHead")(p);
                memo[tuple(`TemplateHead`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateHead(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateHead")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("\u0060")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateHead"), "TemplateHead")(TParseTree("", false,[], s));
        }
    }
    static string TemplateHead(GetName g)
    {
        return "ES6.TemplateHead";
    }

    static TParseTree TemplateSubstitutionTail(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(TemplateMiddle, TemplateTail), "ES6.TemplateSubstitutionTail")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateSubstitutionTail`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(TemplateMiddle, TemplateTail), "ES6.TemplateSubstitutionTail"), "TemplateSubstitutionTail")(p);
                memo[tuple(`TemplateSubstitutionTail`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateSubstitutionTail(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(TemplateMiddle, TemplateTail), "ES6.TemplateSubstitutionTail")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(TemplateMiddle, TemplateTail), "ES6.TemplateSubstitutionTail"), "TemplateSubstitutionTail")(TParseTree("", false,[], s));
        }
    }
    static string TemplateSubstitutionTail(GetName g)
    {
        return "ES6.TemplateSubstitutionTail";
    }

    static TParseTree TemplateMiddle(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateMiddle")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateMiddle`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateMiddle"), "TemplateMiddle")(p);
                memo[tuple(`TemplateMiddle`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateMiddle(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateMiddle")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("${"))), "ES6.TemplateMiddle"), "TemplateMiddle")(TParseTree("", false,[], s));
        }
    }
    static string TemplateMiddle(GetName g)
    {
        return "ES6.TemplateMiddle";
    }

    static TParseTree TemplateTail(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.TemplateTail")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateTail`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.TemplateTail"), "TemplateTail")(p);
                memo[tuple(`TemplateTail`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateTail(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.TemplateTail")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("}")), pegged.peg.option!(TemplateCharacters), pegged.peg.discard!(pegged.peg.literal!("\u0060"))), "ES6.TemplateTail"), "TemplateTail")(TParseTree("", false,[], s));
        }
    }
    static string TemplateTail(GetName g)
    {
        return "ES6.TemplateTail";
    }

    static TParseTree TemplateCharacters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(TemplateCharacter), "ES6.TemplateCharacters")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateCharacters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(TemplateCharacter), "ES6.TemplateCharacters"), "TemplateCharacters")(p);
                memo[tuple(`TemplateCharacters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateCharacters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(TemplateCharacter), "ES6.TemplateCharacters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(TemplateCharacter), "ES6.TemplateCharacters"), "TemplateCharacters")(TParseTree("", false,[], s));
        }
    }
    static string TemplateCharacters(GetName g)
    {
        return "ES6.TemplateCharacters";
    }

    static TParseTree TemplateCharacter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("$"), pegged.peg.negLookahead!(pegged.peg.literal!("{"))), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation, LineTerminatorSequence, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\u0060"), pegged.peg.literal!("\\"), pegged.peg.literal!("$"), LineTerminator)), SourceCharacter)), "ES6.TemplateCharacter")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateCharacter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("$"), pegged.peg.negLookahead!(pegged.peg.literal!("{"))), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation, LineTerminatorSequence, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\u0060"), pegged.peg.literal!("\\"), pegged.peg.literal!("$"), LineTerminator)), SourceCharacter)), "ES6.TemplateCharacter"), "TemplateCharacter")(p);
                memo[tuple(`TemplateCharacter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateCharacter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("$"), pegged.peg.negLookahead!(pegged.peg.literal!("{"))), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation, LineTerminatorSequence, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\u0060"), pegged.peg.literal!("\\"), pegged.peg.literal!("$"), LineTerminator)), SourceCharacter)), "ES6.TemplateCharacter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("$"), pegged.peg.negLookahead!(pegged.peg.literal!("{"))), pegged.peg.and!(pegged.peg.literal!("\\"), EscapeSequence), LineContinuation, LineTerminatorSequence, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.or!(pegged.peg.literal!("\u0060"), pegged.peg.literal!("\\"), pegged.peg.literal!("$"), LineTerminator)), SourceCharacter)), "ES6.TemplateCharacter"), "TemplateCharacter")(TParseTree("", false,[], s));
        }
    }
    static string TemplateCharacter(GetName g)
    {
        return "ES6.TemplateCharacter";
    }

    static TParseTree IdentifierReference(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.IdentifierReference")(p);
        }
        else
        {
            if(auto m = tuple(`IdentifierReference`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.IdentifierReference"), "IdentifierReference")(p);
                memo[tuple(`IdentifierReference`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IdentifierReference(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.IdentifierReference")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.IdentifierReference"), "IdentifierReference")(TParseTree("", false,[], s));
        }
    }
    static string IdentifierReference(GetName g)
    {
        return "ES6.IdentifierReference";
    }

    static TParseTree IdentifierReferenceYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.IdentifierReferenceYield")(p);
        }
        else
        {
            if(auto m = tuple(`IdentifierReferenceYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.IdentifierReferenceYield"), "IdentifierReferenceYield")(p);
                memo[tuple(`IdentifierReferenceYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IdentifierReferenceYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.IdentifierReferenceYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.IdentifierReferenceYield"), "IdentifierReferenceYield")(TParseTree("", false,[], s));
        }
    }
    static string IdentifierReferenceYield(GetName g)
    {
        return "ES6.IdentifierReferenceYield";
    }

    static TParseTree BindingIdentifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.BindingIdentifier")(p);
        }
        else
        {
            if(auto m = tuple(`BindingIdentifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.BindingIdentifier"), "BindingIdentifier")(p);
                memo[tuple(`BindingIdentifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingIdentifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.BindingIdentifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.BindingIdentifier"), "BindingIdentifier")(TParseTree("", false,[], s));
        }
    }
    static string BindingIdentifier(GetName g)
    {
        return "ES6.BindingIdentifier";
    }

    static TParseTree BindingIdentifierYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.BindingIdentifierYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingIdentifierYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.BindingIdentifierYield"), "BindingIdentifierYield")(p);
                memo[tuple(`BindingIdentifierYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingIdentifierYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.BindingIdentifierYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.BindingIdentifierYield"), "BindingIdentifierYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingIdentifierYield(GetName g)
    {
        return "ES6.BindingIdentifierYield";
    }

    static TParseTree LabelIdentifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.LabelIdentifier")(p);
        }
        else
        {
            if(auto m = tuple(`LabelIdentifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.LabelIdentifier"), "LabelIdentifier")(p);
                memo[tuple(`LabelIdentifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelIdentifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.LabelIdentifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("yield"), Spacing)), "ES6.LabelIdentifier"), "LabelIdentifier")(TParseTree("", false,[], s));
        }
    }
    static string LabelIdentifier(GetName g)
    {
        return "ES6.LabelIdentifier";
    }

    static TParseTree LabelIdentifierYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.LabelIdentifierYield")(p);
        }
        else
        {
            if(auto m = tuple(`LabelIdentifierYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.LabelIdentifierYield"), "LabelIdentifierYield")(p);
                memo[tuple(`LabelIdentifierYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelIdentifierYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.LabelIdentifierYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Identifier, Spacing), "ES6.LabelIdentifierYield"), "LabelIdentifierYield")(TParseTree("", false,[], s));
        }
    }
    static string LabelIdentifierYield(GetName g)
    {
        return "ES6.LabelIdentifierYield";
    }

    static TParseTree Identifier(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.and!(ReservedWord, pegged.peg.or!(WhiteSpace, LineTerminatorSequence, Comment, pegged.peg.literal!(";"), pegged.peg.literal!(":")))), IdentifierName), "ES6.Identifier")(p);
        }
        else
        {
            if(auto m = tuple(`Identifier`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.and!(ReservedWord, pegged.peg.or!(WhiteSpace, LineTerminatorSequence, Comment, pegged.peg.literal!(";"), pegged.peg.literal!(":")))), IdentifierName), "ES6.Identifier"), "Identifier")(p);
                memo[tuple(`Identifier`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Identifier(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.and!(ReservedWord, pegged.peg.or!(WhiteSpace, LineTerminatorSequence, Comment, pegged.peg.literal!(";"), pegged.peg.literal!(":")))), IdentifierName), "ES6.Identifier")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.and!(ReservedWord, pegged.peg.or!(WhiteSpace, LineTerminatorSequence, Comment, pegged.peg.literal!(";"), pegged.peg.literal!(":")))), IdentifierName), "ES6.Identifier"), "Identifier")(TParseTree("", false,[], s));
        }
    }
    static string Identifier(GetName g)
    {
        return "ES6.Identifier";
    }

    static TParseTree ThisKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("this"), pegged.peg.negLookahead!(IdentifierPart)), "ES6.ThisKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`ThisKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("this"), pegged.peg.negLookahead!(IdentifierPart)), "ES6.ThisKeyword"), "ThisKeyword")(p);
                memo[tuple(`ThisKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ThisKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("this"), pegged.peg.negLookahead!(IdentifierPart)), "ES6.ThisKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("this"), pegged.peg.negLookahead!(IdentifierPart)), "ES6.ThisKeyword"), "ThisKeyword")(TParseTree("", false,[], s));
        }
    }
    static string ThisKeyword(GetName g)
    {
        return "ES6.ThisKeyword";
    }

    static TParseTree PrimaryExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteral, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteral, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpression, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PrimaryExpression")(p);
        }
        else
        {
            if(auto m = tuple(`PrimaryExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteral, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteral, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpression, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PrimaryExpression"), "PrimaryExpression")(p);
                memo[tuple(`PrimaryExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PrimaryExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteral, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteral, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpression, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PrimaryExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteral, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteral, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpression, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PrimaryExpression"), "PrimaryExpression")(TParseTree("", false,[], s));
        }
    }
    static string PrimaryExpression(GetName g)
    {
        return "ES6.PrimaryExpression";
    }

    static TParseTree PrimaryExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PrimaryExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`PrimaryExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PrimaryExpressionYield"), "PrimaryExpressionYield")(p);
                memo[tuple(`PrimaryExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PrimaryExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PrimaryExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ThisKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Literal, Spacing), pegged.peg.wrapAround!(Spacing, ArrayLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ObjectLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, GeneratorExpression, Spacing), pegged.peg.wrapAround!(Spacing, ClassExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionExpression, Spacing), pegged.peg.wrapAround!(Spacing, RegularExpressionLiteral, Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PrimaryExpressionYield"), "PrimaryExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string PrimaryExpressionYield(GetName g)
    {
        return "ES6.PrimaryExpressionYield";
    }

    static TParseTree CoverParenthesizedExpressionAndArrowParameterList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterList")(p);
        }
        else
        {
            if(auto m = tuple(`CoverParenthesizedExpressionAndArrowParameterList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterList"), "CoverParenthesizedExpressionAndArrowParameterList")(p);
                memo[tuple(`CoverParenthesizedExpressionAndArrowParameterList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CoverParenthesizedExpressionAndArrowParameterList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterList"), "CoverParenthesizedExpressionAndArrowParameterList")(TParseTree("", false,[], s));
        }
    }
    static string CoverParenthesizedExpressionAndArrowParameterList(GetName g)
    {
        return "ES6.CoverParenthesizedExpressionAndArrowParameterList";
    }

    static TParseTree CoverParenthesizedExpressionAndArrowParameterListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterListYield")(p);
        }
        else
        {
            if(auto m = tuple(`CoverParenthesizedExpressionAndArrowParameterListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterListYield"), "CoverParenthesizedExpressionAndArrowParameterListYield")(p);
                memo[tuple(`CoverParenthesizedExpressionAndArrowParameterListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CoverParenthesizedExpressionAndArrowParameterListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing)), "ES6.CoverParenthesizedExpressionAndArrowParameterListYield"), "CoverParenthesizedExpressionAndArrowParameterListYield")(TParseTree("", false,[], s));
        }
    }
    static string CoverParenthesizedExpressionAndArrowParameterListYield(GetName g)
    {
        return "ES6.CoverParenthesizedExpressionAndArrowParameterListYield";
    }

    static TParseTree ParenthesizedExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), "ES6.ParenthesizedExpression")(p);
        }
        else
        {
            if(auto m = tuple(`ParenthesizedExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), "ES6.ParenthesizedExpression"), "ParenthesizedExpression")(p);
                memo[tuple(`ParenthesizedExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ParenthesizedExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), "ES6.ParenthesizedExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), "ES6.ParenthesizedExpression"), "ParenthesizedExpression")(TParseTree("", false,[], s));
        }
    }
    static string ParenthesizedExpression(GetName g)
    {
        return "ES6.ParenthesizedExpression";
    }

    static TParseTree ParenthesizedExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), "ES6.ParenthesizedExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`ParenthesizedExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), "ES6.ParenthesizedExpressionYield"), "ParenthesizedExpressionYield")(p);
                memo[tuple(`ParenthesizedExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ParenthesizedExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), "ES6.ParenthesizedExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), "ES6.ParenthesizedExpressionYield"), "ParenthesizedExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string ParenthesizedExpressionYield(GetName g)
    {
        return "ES6.ParenthesizedExpressionYield";
    }

    static TParseTree Literal(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.or!(NullLiteral, BooleanLiteral, NumericLiteral), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), StringLiteral), "ES6.Literal")(p);
        }
        else
        {
            if(auto m = tuple(`Literal`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.or!(NullLiteral, BooleanLiteral, NumericLiteral), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), StringLiteral), "ES6.Literal"), "Literal")(p);
                memo[tuple(`Literal`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Literal(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.or!(NullLiteral, BooleanLiteral, NumericLiteral), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), StringLiteral), "ES6.Literal")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.or!(NullLiteral, BooleanLiteral, NumericLiteral), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), StringLiteral), "ES6.Literal"), "Literal")(TParseTree("", false,[], s));
        }
    }
    static string Literal(GetName g)
    {
        return "ES6.Literal";
    }

    static TParseTree ArrayLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementList, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`ArrayLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementList, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteral"), "ArrayLiteral")(p);
                memo[tuple(`ArrayLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrayLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementList, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementList, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteral"), "ArrayLiteral")(TParseTree("", false,[], s));
        }
    }
    static string ArrayLiteral(GetName g)
    {
        return "ES6.ArrayLiteral";
    }

    static TParseTree ArrayLiteralYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementListYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteralYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrayLiteralYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementListYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteralYield"), "ArrayLiteralYield")(p);
                memo[tuple(`ArrayLiteralYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrayLiteralYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementListYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteralYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ElementListYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)))), Spacing), "ES6.ArrayLiteralYield"), "ArrayLiteralYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrayLiteralYield(GetName g)
    {
        return "ES6.ArrayLiteralYield";
    }

    static TParseTree ElementList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing)), Spacing))), "ES6.ElementList")(p);
        }
        else
        {
            if(auto m = tuple(`ElementList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing)), Spacing))), "ES6.ElementList"), "ElementList")(p);
                memo[tuple(`ElementList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ElementList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing)), Spacing))), "ES6.ElementList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing)), Spacing))), "ES6.ElementList"), "ElementList")(TParseTree("", false,[], s));
        }
    }
    static string ElementList(GetName g)
    {
        return "ES6.ElementList";
    }

    static TParseTree ElementListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing)), Spacing))), "ES6.ElementListYield")(p);
        }
        else
        {
            if(auto m = tuple(`ElementListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing)), Spacing))), "ES6.ElementListYield"), "ElementListYield")(p);
                memo[tuple(`ElementListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ElementListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing)), Spacing))), "ES6.ElementListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, SpreadElementYield, Spacing)), Spacing)), Spacing))), "ES6.ElementListYield"), "ElementListYield")(TParseTree("", false,[], s));
        }
    }
    static string ElementListYield(GetName g)
    {
        return "ES6.ElementListYield";
    }

    static TParseTree Elision(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), "ES6.Elision")(p);
        }
        else
        {
            if(auto m = tuple(`Elision`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), "ES6.Elision"), "Elision")(p);
                memo[tuple(`Elision`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Elision(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), "ES6.Elision")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), "ES6.Elision"), "Elision")(TParseTree("", false,[], s));
        }
    }
    static string Elision(GetName g)
    {
        return "ES6.Elision";
    }

    static TParseTree SpreadElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.SpreadElement")(p);
        }
        else
        {
            if(auto m = tuple(`SpreadElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.SpreadElement"), "SpreadElement")(p);
                memo[tuple(`SpreadElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SpreadElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.SpreadElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.SpreadElement"), "SpreadElement")(TParseTree("", false,[], s));
        }
    }
    static string SpreadElement(GetName g)
    {
        return "ES6.SpreadElement";
    }

    static TParseTree SpreadElementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.SpreadElementYield")(p);
        }
        else
        {
            if(auto m = tuple(`SpreadElementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.SpreadElementYield"), "SpreadElementYield")(p);
                memo[tuple(`SpreadElementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SpreadElementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.SpreadElementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.SpreadElementYield"), "SpreadElementYield")(TParseTree("", false,[], s));
        }
    }
    static string SpreadElementYield(GetName g)
    {
        return "ES6.SpreadElementYield";
    }

    static TParseTree ObjectLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionList, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`ObjectLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionList, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteral"), "ObjectLiteral")(p);
                memo[tuple(`ObjectLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ObjectLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionList, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionList, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteral"), "ObjectLiteral")(TParseTree("", false,[], s));
        }
    }
    static string ObjectLiteral(GetName g)
    {
        return "ES6.ObjectLiteral";
    }

    static TParseTree ObjectLiteralYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionListYield, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteralYield")(p);
        }
        else
        {
            if(auto m = tuple(`ObjectLiteralYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionListYield, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteralYield"), "ObjectLiteralYield")(p);
                memo[tuple(`ObjectLiteralYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ObjectLiteralYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionListYield, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteralYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionListYield, Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)))), Spacing))), Spacing), "ES6.ObjectLiteralYield"), "ObjectLiteralYield")(TParseTree("", false,[], s));
        }
    }
    static string ObjectLiteralYield(GetName g)
    {
        return "ES6.ObjectLiteralYield";
    }

    static TParseTree PropertyDefinitionList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing)), Spacing))), "ES6.PropertyDefinitionList")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyDefinitionList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing)), Spacing))), "ES6.PropertyDefinitionList"), "PropertyDefinitionList")(p);
                memo[tuple(`PropertyDefinitionList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyDefinitionList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing)), Spacing))), "ES6.PropertyDefinitionList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinition, Spacing)), Spacing))), "ES6.PropertyDefinitionList"), "PropertyDefinitionList")(TParseTree("", false,[], s));
        }
    }
    static string PropertyDefinitionList(GetName g)
    {
        return "ES6.PropertyDefinitionList";
    }

    static TParseTree PropertyDefinitionListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing)), Spacing))), "ES6.PropertyDefinitionListYield")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyDefinitionListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing)), Spacing))), "ES6.PropertyDefinitionListYield"), "PropertyDefinitionListYield")(p);
                memo[tuple(`PropertyDefinitionListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyDefinitionListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing)), Spacing))), "ES6.PropertyDefinitionListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, PropertyDefinitionYield, Spacing)), Spacing))), "ES6.PropertyDefinitionListYield"), "PropertyDefinitionListYield")(TParseTree("", false,[], s));
        }
    }
    static string PropertyDefinitionListYield(GetName g)
    {
        return "ES6.PropertyDefinitionListYield";
    }

    static TParseTree PropertyDefinition(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PropertyDefinition")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyDefinition`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PropertyDefinition"), "PropertyDefinition")(p);
                memo[tuple(`PropertyDefinition`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyDefinition(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PropertyDefinition")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing)), "ES6.PropertyDefinition"), "PropertyDefinition")(TParseTree("", false,[], s));
        }
    }
    static string PropertyDefinition(GetName g)
    {
        return "ES6.PropertyDefinition";
    }

    static TParseTree PropertyDefinitionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PropertyDefinitionYield")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyDefinitionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PropertyDefinitionYield"), "PropertyDefinitionYield")(p);
                memo[tuple(`PropertyDefinitionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyDefinitionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PropertyDefinitionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverInitializedNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing)), "ES6.PropertyDefinitionYield"), "PropertyDefinitionYield")(TParseTree("", false,[], s));
        }
    }
    static string PropertyDefinitionYield(GetName g)
    {
        return "ES6.PropertyDefinitionYield";
    }

    static TParseTree PropertyName(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyName, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyName")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyName`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyName, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyName"), "PropertyName")(p);
                memo[tuple(`PropertyName`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyName(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyName, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyName")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyName, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyName"), "PropertyName")(TParseTree("", false,[], s));
        }
    }
    static string PropertyName(GetName g)
    {
        return "ES6.PropertyName";
    }

    static TParseTree PropertyNameYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyNameYield")(p);
        }
        else
        {
            if(auto m = tuple(`PropertyNameYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyNameYield"), "PropertyNameYield")(p);
                memo[tuple(`PropertyNameYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertyNameYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyNameYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ComputedPropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, LiteralPropertyName, Spacing)), "ES6.PropertyNameYield"), "PropertyNameYield")(TParseTree("", false,[], s));
        }
    }
    static string PropertyNameYield(GetName g)
    {
        return "ES6.PropertyNameYield";
    }

    static TParseTree LiteralPropertyName(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NumericLiteral, Spacing), pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.LiteralPropertyName")(p);
        }
        else
        {
            if(auto m = tuple(`LiteralPropertyName`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NumericLiteral, Spacing), pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.LiteralPropertyName"), "LiteralPropertyName")(p);
                memo[tuple(`LiteralPropertyName`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LiteralPropertyName(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NumericLiteral, Spacing), pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.LiteralPropertyName")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NumericLiteral, Spacing), pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.LiteralPropertyName"), "LiteralPropertyName")(TParseTree("", false,[], s));
        }
    }
    static string LiteralPropertyName(GetName g)
    {
        return "ES6.LiteralPropertyName";
    }

    static TParseTree ComputedPropertyName(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), "ES6.ComputedPropertyName")(p);
        }
        else
        {
            if(auto m = tuple(`ComputedPropertyName`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), "ES6.ComputedPropertyName"), "ComputedPropertyName")(p);
                memo[tuple(`ComputedPropertyName`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ComputedPropertyName(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), "ES6.ComputedPropertyName")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), "ES6.ComputedPropertyName"), "ComputedPropertyName")(TParseTree("", false,[], s));
        }
    }
    static string ComputedPropertyName(GetName g)
    {
        return "ES6.ComputedPropertyName";
    }

    static TParseTree ComputedPropertyNameYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), "ES6.ComputedPropertyNameYield")(p);
        }
        else
        {
            if(auto m = tuple(`ComputedPropertyNameYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), "ES6.ComputedPropertyNameYield"), "ComputedPropertyNameYield")(p);
                memo[tuple(`ComputedPropertyNameYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ComputedPropertyNameYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), "ES6.ComputedPropertyNameYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing), "ES6.ComputedPropertyNameYield"), "ComputedPropertyNameYield")(TParseTree("", false,[], s));
        }
    }
    static string ComputedPropertyNameYield(GetName g)
    {
        return "ES6.ComputedPropertyNameYield";
    }

    static TParseTree CoverInitializedName(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), "ES6.CoverInitializedName")(p);
        }
        else
        {
            if(auto m = tuple(`CoverInitializedName`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), "ES6.CoverInitializedName"), "CoverInitializedName")(p);
                memo[tuple(`CoverInitializedName`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CoverInitializedName(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), "ES6.CoverInitializedName")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReference, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), "ES6.CoverInitializedName"), "CoverInitializedName")(TParseTree("", false,[], s));
        }
    }
    static string CoverInitializedName(GetName g)
    {
        return "ES6.CoverInitializedName";
    }

    static TParseTree CoverInitializedNameYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), "ES6.CoverInitializedNameYield")(p);
        }
        else
        {
            if(auto m = tuple(`CoverInitializedNameYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), "ES6.CoverInitializedNameYield"), "CoverInitializedNameYield")(p);
                memo[tuple(`CoverInitializedNameYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CoverInitializedNameYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), "ES6.CoverInitializedNameYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, IdentifierReferenceYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), "ES6.CoverInitializedNameYield"), "CoverInitializedNameYield")(TParseTree("", false,[], s));
        }
    }
    static string CoverInitializedNameYield(GetName g)
    {
        return "ES6.CoverInitializedNameYield";
    }

    static TParseTree Initializer(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), "ES6.Initializer")(p);
        }
        else
        {
            if(auto m = tuple(`Initializer`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), "ES6.Initializer"), "Initializer")(p);
                memo[tuple(`Initializer`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Initializer(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), "ES6.Initializer")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), "ES6.Initializer"), "Initializer")(TParseTree("", false,[], s));
        }
    }
    static string Initializer(GetName g)
    {
        return "ES6.Initializer";
    }

    static TParseTree InitializerIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.InitializerIn")(p);
        }
        else
        {
            if(auto m = tuple(`InitializerIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.InitializerIn"), "InitializerIn")(p);
                memo[tuple(`InitializerIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InitializerIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.InitializerIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), "ES6.InitializerIn"), "InitializerIn")(TParseTree("", false,[], s));
        }
    }
    static string InitializerIn(GetName g)
    {
        return "ES6.InitializerIn";
    }

    static TParseTree InitializerYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), "ES6.InitializerYield")(p);
        }
        else
        {
            if(auto m = tuple(`InitializerYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), "ES6.InitializerYield"), "InitializerYield")(p);
                memo[tuple(`InitializerYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InitializerYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), "ES6.InitializerYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), "ES6.InitializerYield"), "InitializerYield")(TParseTree("", false,[], s));
        }
    }
    static string InitializerYield(GetName g)
    {
        return "ES6.InitializerYield";
    }

    static TParseTree InitializerInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.InitializerInYield")(p);
        }
        else
        {
            if(auto m = tuple(`InitializerInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.InitializerInYield"), "InitializerInYield")(p);
                memo[tuple(`InitializerInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InitializerInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.InitializerInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), "ES6.InitializerInYield"), "InitializerInYield")(TParseTree("", false,[], s));
        }
    }
    static string InitializerInYield(GetName g)
    {
        return "ES6.InitializerInYield";
    }

    static TParseTree TemplateLiteral(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpans, Spacing)), Spacing)), "ES6.TemplateLiteral")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateLiteral`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpans, Spacing)), Spacing)), "ES6.TemplateLiteral"), "TemplateLiteral")(p);
                memo[tuple(`TemplateLiteral`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateLiteral(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpans, Spacing)), Spacing)), "ES6.TemplateLiteral")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpans, Spacing)), Spacing)), "ES6.TemplateLiteral"), "TemplateLiteral")(TParseTree("", false,[], s));
        }
    }
    static string TemplateLiteral(GetName g)
    {
        return "ES6.TemplateLiteral";
    }

    static TParseTree TemplateLiteralYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpansYield, Spacing)), Spacing)), "ES6.TemplateLiteralYield")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateLiteralYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpansYield, Spacing)), Spacing)), "ES6.TemplateLiteralYield"), "TemplateLiteralYield")(p);
                memo[tuple(`TemplateLiteralYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateLiteralYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpansYield, Spacing)), Spacing)), "ES6.TemplateLiteralYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, NoSubstitutionTemplate, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, TemplateHead, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, TemplateSpansYield, Spacing)), Spacing)), "ES6.TemplateLiteralYield"), "TemplateLiteralYield")(TParseTree("", false,[], s));
        }
    }
    static string TemplateLiteralYield(GetName g)
    {
        return "ES6.TemplateLiteralYield";
    }

    static TParseTree TemplateSpans(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpans")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateSpans`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpans"), "TemplateSpans")(p);
                memo[tuple(`TemplateSpans`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateSpans(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpans")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpans"), "TemplateSpans")(TParseTree("", false,[], s));
        }
    }
    static string TemplateSpans(GetName g)
    {
        return "ES6.TemplateSpans";
    }

    static TParseTree TemplateSpansYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpansYield")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateSpansYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpansYield"), "TemplateSpansYield")(p);
                memo[tuple(`TemplateSpansYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateSpansYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpansYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateTail, Spacing)), "ES6.TemplateSpansYield"), "TemplateSpansYield")(TParseTree("", false,[], s));
        }
    }
    static string TemplateSpansYield(GetName g)
    {
        return "ES6.TemplateSpansYield";
    }

    static TParseTree TemplateMiddleList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.TemplateMiddleList")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateMiddleList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.TemplateMiddleList"), "TemplateMiddleList")(p);
                memo[tuple(`TemplateMiddleList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateMiddleList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.TemplateMiddleList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleList, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.TemplateMiddleList"), "TemplateMiddleList")(TParseTree("", false,[], s));
        }
    }
    static string TemplateMiddleList(GetName g)
    {
        return "ES6.TemplateMiddleList";
    }

    static TParseTree TemplateMiddleListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.TemplateMiddleListYield")(p);
        }
        else
        {
            if(auto m = tuple(`TemplateMiddleListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.TemplateMiddleListYield"), "TemplateMiddleListYield")(p);
                memo[tuple(`TemplateMiddleListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TemplateMiddleListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.TemplateMiddleListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, TemplateMiddleListYield, Spacing)), pegged.peg.wrapAround!(Spacing, TemplateMiddle, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.TemplateMiddleListYield"), "TemplateMiddleListYield")(TParseTree("", false,[], s));
        }
    }
    static string TemplateMiddleListYield(GetName g)
    {
        return "ES6.TemplateMiddleListYield";
    }

    static TParseTree FieldAccessor(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.FieldAccessor")(p);
        }
        else
        {
            if(auto m = tuple(`FieldAccessor`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.FieldAccessor"), "FieldAccessor")(p);
                memo[tuple(`FieldAccessor`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FieldAccessor(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.FieldAccessor")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.wrapAround!(Spacing, IdentifierName, Spacing)), "ES6.FieldAccessor"), "FieldAccessor")(TParseTree("", false,[], s));
        }
    }
    static string FieldAccessor(GetName g)
    {
        return "ES6.FieldAccessor";
    }

    static TParseTree MemberExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), "ES6.MemberExpression")(p);
        }
        else
        {
            if(auto m = tuple(`MemberExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), "ES6.MemberExpression"), "MemberExpression")(p);
                memo[tuple(`MemberExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MemberExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), "ES6.MemberExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperProperty, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpression, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing)), Spacing))), "ES6.MemberExpression"), "MemberExpression")(TParseTree("", false,[], s));
        }
    }
    static string MemberExpression(GetName g)
    {
        return "ES6.MemberExpression";
    }

    static TParseTree MemberExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), "ES6.MemberExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`MemberExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), "ES6.MemberExpressionYield"), "MemberExpressionYield")(p);
                memo[tuple(`MemberExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MemberExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), "ES6.MemberExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperPropertyYield, Spacing), pegged.peg.wrapAround!(Spacing, MetaProperty, Spacing), pegged.peg.wrapAround!(Spacing, PrimaryExpressionYield, Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing)), Spacing))), "ES6.MemberExpressionYield"), "MemberExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string MemberExpressionYield(GetName g)
    {
        return "ES6.MemberExpressionYield";
    }

    static TParseTree SuperProperty(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperProperty")(p);
        }
        else
        {
            if(auto m = tuple(`SuperProperty`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperProperty"), "SuperProperty")(p);
                memo[tuple(`SuperProperty`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SuperProperty(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperProperty")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperProperty"), "SuperProperty")(TParseTree("", false,[], s));
        }
    }
    static string SuperProperty(GetName g)
    {
        return "ES6.SuperProperty";
    }

    static TParseTree SuperPropertyYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperPropertyYield")(p);
        }
        else
        {
            if(auto m = tuple(`SuperPropertyYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperPropertyYield"), "SuperPropertyYield")(p);
                memo[tuple(`SuperPropertyYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SuperPropertyYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperPropertyYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing)), Spacing)), "ES6.SuperPropertyYield"), "SuperPropertyYield")(TParseTree("", false,[], s));
        }
    }
    static string SuperPropertyYield(GetName g)
    {
        return "ES6.SuperPropertyYield";
    }

    static TParseTree MetaProperty(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, NewTarget, Spacing), "ES6.MetaProperty")(p);
        }
        else
        {
            if(auto m = tuple(`MetaProperty`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, NewTarget, Spacing), "ES6.MetaProperty"), "MetaProperty")(p);
                memo[tuple(`MetaProperty`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MetaProperty(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, NewTarget, Spacing), "ES6.MetaProperty")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, NewTarget, Spacing), "ES6.MetaProperty"), "MetaProperty")(TParseTree("", false,[], s));
        }
    }
    static string MetaProperty(GetName g)
    {
        return "ES6.MetaProperty";
    }

    static TParseTree NewKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("new"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.NewKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`NewKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("new"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.NewKeyword"), "NewKeyword")(p);
                memo[tuple(`NewKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NewKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("new"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.NewKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("new"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.NewKeyword"), "NewKeyword")(TParseTree("", false,[], s));
        }
    }
    static string NewKeyword(GetName g)
    {
        return "ES6.NewKeyword";
    }

    static TParseTree NewTarget(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("new"), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("target"), Spacing))), "ES6.NewTarget")(p);
        }
        else
        {
            if(auto m = tuple(`NewTarget`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("new"), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("target"), Spacing))), "ES6.NewTarget"), "NewTarget")(p);
                memo[tuple(`NewTarget`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NewTarget(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("new"), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("target"), Spacing))), "ES6.NewTarget")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("new"), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("."), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("target"), Spacing))), "ES6.NewTarget"), "NewTarget")(TParseTree("", false,[], s));
        }
    }
    static string NewTarget(GetName g)
    {
        return "ES6.NewTarget";
    }

    static TParseTree NewExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing)), Spacing)), "ES6.NewExpression")(p);
        }
        else
        {
            if(auto m = tuple(`NewExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing)), Spacing)), "ES6.NewExpression"), "NewExpression")(p);
                memo[tuple(`NewExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NewExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing)), Spacing)), "ES6.NewExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing)), Spacing)), "ES6.NewExpression"), "NewExpression")(TParseTree("", false,[], s));
        }
    }
    static string NewExpression(GetName g)
    {
        return "ES6.NewExpression";
    }

    static TParseTree NewExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing)), Spacing)), "ES6.NewExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`NewExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing)), Spacing)), "ES6.NewExpressionYield"), "NewExpressionYield")(p);
                memo[tuple(`NewExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree NewExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing)), Spacing)), "ES6.NewExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, NewKeyword, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, WhiteSpace, Spacing))), Spacing)), pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing)), Spacing)), "ES6.NewExpressionYield"), "NewExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string NewExpressionYield(GetName g)
    {
        return "ES6.NewExpressionYield";
    }

    static TParseTree CallExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCall, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing))), "ES6.CallExpression")(p);
        }
        else
        {
            if(auto m = tuple(`CallExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCall, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing))), "ES6.CallExpression"), "CallExpression")(p);
                memo[tuple(`CallExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CallExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCall, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing))), "ES6.CallExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCall, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpression, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteral, Spacing), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), Spacing))), "ES6.CallExpression"), "CallExpression")(TParseTree("", false,[], s));
        }
    }
    static string CallExpression(GetName g)
    {
        return "ES6.CallExpression";
    }

    static TParseTree CallExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCallYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing))), "ES6.CallExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`CallExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCallYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing))), "ES6.CallExpressionYield"), "CallExpressionYield")(p);
                memo[tuple(`CallExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CallExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCallYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing))), "ES6.CallExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SuperCallYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, MemberExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing)), Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, FieldAccessor, Spacing), Spacing), pegged.peg.wrapAround!(Spacing, TemplateLiteralYield, Spacing), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), Spacing))), "ES6.CallExpressionYield"), "CallExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string CallExpressionYield(GetName g)
    {
        return "ES6.CallExpressionYield";
    }

    static TParseTree SuperCall(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), "ES6.SuperCall")(p);
        }
        else
        {
            if(auto m = tuple(`SuperCall`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), "ES6.SuperCall"), "SuperCall")(p);
                memo[tuple(`SuperCall`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SuperCall(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), "ES6.SuperCall")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, Arguments, Spacing)), "ES6.SuperCall"), "SuperCall")(TParseTree("", false,[], s));
        }
    }
    static string SuperCall(GetName g)
    {
        return "ES6.SuperCall";
    }

    static TParseTree SuperCallYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), "ES6.SuperCallYield")(p);
        }
        else
        {
            if(auto m = tuple(`SuperCallYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), "ES6.SuperCallYield"), "SuperCallYield")(p);
                memo[tuple(`SuperCallYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SuperCallYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), "ES6.SuperCallYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("super"), Spacing)), pegged.peg.wrapAround!(Spacing, ArgumentsYield, Spacing)), "ES6.SuperCallYield"), "SuperCallYield")(TParseTree("", false,[], s));
        }
    }
    static string SuperCallYield(GetName g)
    {
        return "ES6.SuperCallYield";
    }

    static TParseTree Arguments(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing))), Spacing), "ES6.Arguments")(p);
        }
        else
        {
            if(auto m = tuple(`Arguments`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing))), Spacing), "ES6.Arguments"), "Arguments")(p);
                memo[tuple(`Arguments`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Arguments(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing))), Spacing), "ES6.Arguments")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing))), Spacing), "ES6.Arguments"), "Arguments")(TParseTree("", false,[], s));
        }
    }
    static string Arguments(GetName g)
    {
        return "ES6.Arguments";
    }

    static TParseTree ArgumentsYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing))), Spacing), "ES6.ArgumentsYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArgumentsYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing))), Spacing), "ES6.ArgumentsYield"), "ArgumentsYield")(p);
                memo[tuple(`ArgumentsYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArgumentsYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing))), Spacing), "ES6.ArgumentsYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing))), Spacing), "ES6.ArgumentsYield"), "ArgumentsYield")(TParseTree("", false,[], s));
        }
    }
    static string ArgumentsYield(GetName g)
    {
        return "ES6.ArgumentsYield";
    }

    static TParseTree ArgumentList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing)), Spacing))), "ES6.ArgumentList")(p);
        }
        else
        {
            if(auto m = tuple(`ArgumentList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing)), Spacing))), "ES6.ArgumentList"), "ArgumentList")(p);
                memo[tuple(`ArgumentList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArgumentList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing)), Spacing))), "ES6.ArgumentList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentList, Spacing)), Spacing))), "ES6.ArgumentList"), "ArgumentList")(TParseTree("", false,[], s));
        }
    }
    static string ArgumentList(GetName g)
    {
        return "ES6.ArgumentList";
    }

    static TParseTree ArgumentListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing)), Spacing))), "ES6.ArgumentListYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArgumentListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing)), Spacing))), "ES6.ArgumentListYield"), "ArgumentListYield")(p);
                memo[tuple(`ArgumentListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArgumentListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing)), Spacing))), "ES6.ArgumentListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), pegged.peg.wrapAround!(Spacing, ArgumentListYield, Spacing)), Spacing))), "ES6.ArgumentListYield"), "ArgumentListYield")(TParseTree("", false,[], s));
        }
    }
    static string ArgumentListYield(GetName g)
    {
        return "ES6.ArgumentListYield";
    }

    static TParseTree LeftHandSideExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpression, Spacing), pegged.peg.wrapAround!(Spacing, NewExpression, Spacing)), "ES6.LeftHandSideExpression")(p);
        }
        else
        {
            if(auto m = tuple(`LeftHandSideExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpression, Spacing), pegged.peg.wrapAround!(Spacing, NewExpression, Spacing)), "ES6.LeftHandSideExpression"), "LeftHandSideExpression")(p);
                memo[tuple(`LeftHandSideExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LeftHandSideExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpression, Spacing), pegged.peg.wrapAround!(Spacing, NewExpression, Spacing)), "ES6.LeftHandSideExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpression, Spacing), pegged.peg.wrapAround!(Spacing, NewExpression, Spacing)), "ES6.LeftHandSideExpression"), "LeftHandSideExpression")(TParseTree("", false,[], s));
        }
    }
    static string LeftHandSideExpression(GetName g)
    {
        return "ES6.LeftHandSideExpression";
    }

    static TParseTree LeftHandSideExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, NewExpressionYield, Spacing)), "ES6.LeftHandSideExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`LeftHandSideExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, NewExpressionYield, Spacing)), "ES6.LeftHandSideExpressionYield"), "LeftHandSideExpressionYield")(p);
                memo[tuple(`LeftHandSideExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LeftHandSideExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, NewExpressionYield, Spacing)), "ES6.LeftHandSideExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CallExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, NewExpressionYield, Spacing)), "ES6.LeftHandSideExpressionYield"), "LeftHandSideExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string LeftHandSideExpressionYield(GetName g)
    {
        return "ES6.LeftHandSideExpressionYield";
    }

    static TParseTree PostfixExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpression")(p);
        }
        else
        {
            if(auto m = tuple(`PostfixExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpression"), "PostfixExpression")(p);
                memo[tuple(`PostfixExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PostfixExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpression"), "PostfixExpression")(TParseTree("", false,[], s));
        }
    }
    static string PostfixExpression(GetName g)
    {
        return "ES6.PostfixExpression";
    }

    static TParseTree PostfixExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`PostfixExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpressionYield"), "PostfixExpressionYield")(p);
                memo[tuple(`PostfixExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PostfixExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Spaces, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, PostfixOperator, Spacing), Spacing)), Spacing))), "ES6.PostfixExpressionYield"), "PostfixExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string PostfixExpressionYield(GetName g)
    {
        return "ES6.PostfixExpressionYield";
    }

    static TParseTree PostfixOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("++"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("--"), Spacing)), "ES6.PostfixOperator")(p);
        }
        else
        {
            if(auto m = tuple(`PostfixOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("++"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("--"), Spacing)), "ES6.PostfixOperator"), "PostfixOperator")(p);
                memo[tuple(`PostfixOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PostfixOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("++"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("--"), Spacing)), "ES6.PostfixOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("++"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("--"), Spacing)), "ES6.PostfixOperator"), "PostfixOperator")(TParseTree("", false,[], s));
        }
    }
    static string PostfixOperator(GetName g)
    {
        return "ES6.PostfixOperator";
    }

    static TParseTree PrefixExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.keywords!("delete", "void", "typeof"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), pegged.peg.literal!("++"), pegged.peg.literal!("--"), pegged.peg.literal!("+"), pegged.peg.literal!("-"), pegged.peg.literal!("~"), pegged.peg.literal!("!")), "ES6.PrefixExpression")(p);
        }
        else
        {
            if(auto m = tuple(`PrefixExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.keywords!("delete", "void", "typeof"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), pegged.peg.literal!("++"), pegged.peg.literal!("--"), pegged.peg.literal!("+"), pegged.peg.literal!("-"), pegged.peg.literal!("~"), pegged.peg.literal!("!")), "ES6.PrefixExpression"), "PrefixExpression")(p);
                memo[tuple(`PrefixExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PrefixExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.keywords!("delete", "void", "typeof"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), pegged.peg.literal!("++"), pegged.peg.literal!("--"), pegged.peg.literal!("+"), pegged.peg.literal!("-"), pegged.peg.literal!("~"), pegged.peg.literal!("!")), "ES6.PrefixExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.keywords!("delete", "void", "typeof"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), pegged.peg.literal!("++"), pegged.peg.literal!("--"), pegged.peg.literal!("+"), pegged.peg.literal!("-"), pegged.peg.literal!("~"), pegged.peg.literal!("!")), "ES6.PrefixExpression"), "PrefixExpression")(TParseTree("", false,[], s));
        }
    }
    static string PrefixExpression(GetName g)
    {
        return "ES6.PrefixExpression";
    }

    static TParseTree UnaryExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpression, Spacing)), "ES6.UnaryExpression")(p);
        }
        else
        {
            if(auto m = tuple(`UnaryExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpression, Spacing)), "ES6.UnaryExpression"), "UnaryExpression")(p);
                memo[tuple(`UnaryExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree UnaryExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpression, Spacing)), "ES6.UnaryExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpression, Spacing)), "ES6.UnaryExpression"), "UnaryExpression")(TParseTree("", false,[], s));
        }
    }
    static string UnaryExpression(GetName g)
    {
        return "ES6.UnaryExpression";
    }

    static TParseTree UnaryExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpressionYield, Spacing)), "ES6.UnaryExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`UnaryExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpressionYield, Spacing)), "ES6.UnaryExpressionYield"), "UnaryExpressionYield")(p);
                memo[tuple(`UnaryExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree UnaryExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpressionYield, Spacing)), "ES6.UnaryExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, PrefixExpression, Spacing)), pegged.peg.wrapAround!(Spacing, PostfixExpressionYield, Spacing)), "ES6.UnaryExpressionYield"), "UnaryExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string UnaryExpressionYield(GetName g)
    {
        return "ES6.UnaryExpressionYield";
    }

    static TParseTree RightHandSideExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpression, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpression")(p);
        }
        else
        {
            if(auto m = tuple(`RightHandSideExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpression, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpression"), "RightHandSideExpression")(p);
                memo[tuple(`RightHandSideExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RightHandSideExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpression, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpression, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpression"), "RightHandSideExpression")(TParseTree("", false,[], s));
        }
    }
    static string RightHandSideExpression(GetName g)
    {
        return "ES6.RightHandSideExpression";
    }

    static TParseTree RightHandSideExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`RightHandSideExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpressionIn"), "RightHandSideExpressionIn")(p);
                memo[tuple(`RightHandSideExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RightHandSideExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), "ES6.RightHandSideExpressionIn"), "RightHandSideExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string RightHandSideExpressionIn(GetName g)
    {
        return "ES6.RightHandSideExpressionIn";
    }

    static TParseTree RightHandSideExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`RightHandSideExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionYield"), "RightHandSideExpressionYield")(p);
                memo[tuple(`RightHandSideExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RightHandSideExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionYield"), "RightHandSideExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string RightHandSideExpressionYield(GetName g)
    {
        return "ES6.RightHandSideExpressionYield";
    }

    static TParseTree RightHandSideExpressionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`RightHandSideExpressionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionInYield"), "RightHandSideExpressionInYield")(p);
                memo[tuple(`RightHandSideExpressionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RightHandSideExpressionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BinaryExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), "ES6.RightHandSideExpressionInYield"), "RightHandSideExpressionInYield")(TParseTree("", false,[], s));
        }
    }
    static string RightHandSideExpressionInYield(GetName g)
    {
        return "ES6.RightHandSideExpressionInYield";
    }

    static TParseTree BinaryExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpression")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpression"), "BinaryExpression")(p);
                memo[tuple(`BinaryExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpression"), "BinaryExpression")(TParseTree("", false,[], s));
        }
    }
    static string BinaryExpression(GetName g)
    {
        return "ES6.BinaryExpression";
    }

    static TParseTree BinaryExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpressionIn"), "BinaryExpressionIn")(p);
                memo[tuple(`BinaryExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpression, Spacing)), Spacing))), "ES6.BinaryExpressionIn"), "BinaryExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string BinaryExpressionIn(GetName g)
    {
        return "ES6.BinaryExpressionIn";
    }

    static TParseTree BinaryExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionYield"), "BinaryExpressionYield")(p);
                memo[tuple(`BinaryExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperator, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionYield"), "BinaryExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string BinaryExpressionYield(GetName g)
    {
        return "ES6.BinaryExpressionYield";
    }

    static TParseTree BinaryExpressionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`BinaryExpressionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionInYield"), "BinaryExpressionInYield")(p);
                memo[tuple(`BinaryExpressionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BinaryExpressionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing), pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ExpressionOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, UnaryExpressionYield, Spacing)), Spacing))), "ES6.BinaryExpressionInYield"), "BinaryExpressionInYield")(TParseTree("", false,[], s));
        }
    }
    static string BinaryExpressionInYield(GetName g)
    {
        return "ES6.BinaryExpressionInYield";
    }

    static TParseTree ExpressionOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperator, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperator")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperator, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperator"), "ExpressionOperator")(p);
                memo[tuple(`ExpressionOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperator, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperator, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperator"), "ExpressionOperator")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionOperator(GetName g)
    {
        return "ES6.ExpressionOperator";
    }

    static TParseTree ExpressionOperatorIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperatorIn")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionOperatorIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperatorIn"), "ExpressionOperatorIn")(p);
                memo[tuple(`ExpressionOperatorIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionOperatorIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperatorIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, LogicalOperator, Spacing), pegged.peg.wrapAround!(Spacing, BitwiseOperator, Spacing), pegged.peg.wrapAround!(Spacing, EqualityOperator, Spacing), pegged.peg.wrapAround!(Spacing, ShiftOperator, Spacing), pegged.peg.wrapAround!(Spacing, RelationalOperatorIn, Spacing), pegged.peg.wrapAround!(Spacing, AdditiveOperator, Spacing), pegged.peg.wrapAround!(Spacing, MultiplicativeOperator, Spacing)), "ES6.ExpressionOperatorIn"), "ExpressionOperatorIn")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionOperatorIn(GetName g)
    {
        return "ES6.ExpressionOperatorIn";
    }

    static TParseTree LogicalOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("||"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&&"), Spacing)), "ES6.LogicalOperator")(p);
        }
        else
        {
            if(auto m = tuple(`LogicalOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("||"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&&"), Spacing)), "ES6.LogicalOperator"), "LogicalOperator")(p);
                memo[tuple(`LogicalOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LogicalOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("||"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&&"), Spacing)), "ES6.LogicalOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("||"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&&"), Spacing)), "ES6.LogicalOperator"), "LogicalOperator")(TParseTree("", false,[], s));
        }
    }
    static string LogicalOperator(GetName g)
    {
        return "ES6.LogicalOperator";
    }

    static TParseTree BitwiseOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&"), Spacing)), "ES6.BitwiseOperator")(p);
        }
        else
        {
            if(auto m = tuple(`BitwiseOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&"), Spacing)), "ES6.BitwiseOperator"), "BitwiseOperator")(p);
                memo[tuple(`BitwiseOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BitwiseOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&"), Spacing)), "ES6.BitwiseOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&"), Spacing)), "ES6.BitwiseOperator"), "BitwiseOperator")(TParseTree("", false,[], s));
        }
    }
    static string BitwiseOperator(GetName g)
    {
        return "ES6.BitwiseOperator";
    }

    static TParseTree EqualityOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("==="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!="), Spacing)), "ES6.EqualityOperator")(p);
        }
        else
        {
            if(auto m = tuple(`EqualityOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("==="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!="), Spacing)), "ES6.EqualityOperator"), "EqualityOperator")(p);
                memo[tuple(`EqualityOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree EqualityOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("==="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!="), Spacing)), "ES6.EqualityOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("==="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("!="), Spacing)), "ES6.EqualityOperator"), "EqualityOperator")(TParseTree("", false,[], s));
        }
    }
    static string EqualityOperator(GetName g)
    {
        return "ES6.EqualityOperator";
    }

    static TParseTree RelationalOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing)), "ES6.RelationalOperator")(p);
        }
        else
        {
            if(auto m = tuple(`RelationalOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing)), "ES6.RelationalOperator"), "RelationalOperator")(p);
                memo[tuple(`RelationalOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RelationalOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing)), "ES6.RelationalOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing)), "ES6.RelationalOperator"), "RelationalOperator")(TParseTree("", false,[], s));
        }
    }
    static string RelationalOperator(GetName g)
    {
        return "ES6.RelationalOperator";
    }

    static TParseTree RelationalOperatorIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing)), "ES6.RelationalOperatorIn")(p);
        }
        else
        {
            if(auto m = tuple(`RelationalOperatorIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing)), "ES6.RelationalOperatorIn"), "RelationalOperatorIn")(p);
                memo[tuple(`RelationalOperatorIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree RelationalOperatorIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing)), "ES6.RelationalOperatorIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("instanceof"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing)), "ES6.RelationalOperatorIn"), "RelationalOperatorIn")(TParseTree("", false,[], s));
        }
    }
    static string RelationalOperatorIn(GetName g)
    {
        return "ES6.RelationalOperatorIn";
    }

    static TParseTree ShiftOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>"), Spacing)), "ES6.ShiftOperator")(p);
        }
        else
        {
            if(auto m = tuple(`ShiftOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>"), Spacing)), "ES6.ShiftOperator"), "ShiftOperator")(p);
                memo[tuple(`ShiftOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ShiftOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>"), Spacing)), "ES6.ShiftOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>"), Spacing)), "ES6.ShiftOperator"), "ShiftOperator")(TParseTree("", false,[], s));
        }
    }
    static string ShiftOperator(GetName g)
    {
        return "ES6.ShiftOperator";
    }

    static TParseTree AdditiveOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("+", "-"), "ES6.AdditiveOperator")(p);
        }
        else
        {
            if(auto m = tuple(`AdditiveOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.keywords!("+", "-"), "ES6.AdditiveOperator"), "AdditiveOperator")(p);
                memo[tuple(`AdditiveOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AdditiveOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.keywords!("+", "-"), "ES6.AdditiveOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.keywords!("+", "-"), "ES6.AdditiveOperator"), "AdditiveOperator")(TParseTree("", false,[], s));
        }
    }
    static string AdditiveOperator(GetName g)
    {
        return "ES6.AdditiveOperator";
    }

    static TParseTree MultiplicativeOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%"), Spacing)), "ES6.MultiplicativeOperator")(p);
        }
        else
        {
            if(auto m = tuple(`MultiplicativeOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%"), Spacing)), "ES6.MultiplicativeOperator"), "MultiplicativeOperator")(p);
                memo[tuple(`MultiplicativeOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MultiplicativeOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%"), Spacing)), "ES6.MultiplicativeOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%"), Spacing)), "ES6.MultiplicativeOperator"), "MultiplicativeOperator")(TParseTree("", false,[], s));
        }
    }
    static string MultiplicativeOperator(GetName g)
    {
        return "ES6.MultiplicativeOperator";
    }

    static TParseTree ConditionalExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.ConditionalExpression")(p);
        }
        else
        {
            if(auto m = tuple(`ConditionalExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.ConditionalExpression"), "ConditionalExpression")(p);
                memo[tuple(`ConditionalExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConditionalExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.ConditionalExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpression, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.ConditionalExpression"), "ConditionalExpression")(TParseTree("", false,[], s));
        }
    }
    static string ConditionalExpression(GetName g)
    {
        return "ES6.ConditionalExpression";
    }

    static TParseTree ConditionalExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionIn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ConditionalExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`ConditionalExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionIn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ConditionalExpressionIn"), "ConditionalExpressionIn")(p);
                memo[tuple(`ConditionalExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConditionalExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionIn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ConditionalExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionIn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ConditionalExpressionIn"), "ConditionalExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string ConditionalExpressionIn(GetName g)
    {
        return "ES6.ConditionalExpressionIn";
    }

    static TParseTree ConditionalExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ConditionalExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`ConditionalExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ConditionalExpressionYield"), "ConditionalExpressionYield")(p);
                memo[tuple(`ConditionalExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConditionalExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ConditionalExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ConditionalExpressionYield"), "ConditionalExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string ConditionalExpressionYield(GetName g)
    {
        return "ES6.ConditionalExpressionYield";
    }

    static TParseTree ConditionalExpressionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionInYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ConditionalExpressionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`ConditionalExpressionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionInYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ConditionalExpressionInYield"), "ConditionalExpressionInYield")(p);
                memo[tuple(`ConditionalExpressionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConditionalExpressionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionInYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ConditionalExpressionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, RightHandSideExpressionInYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("?"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ConditionalExpressionInYield"), "ConditionalExpressionInYield")(TParseTree("", false,[], s));
        }
    }
    static string ConditionalExpressionInYield(GetName g)
    {
        return "ES6.ConditionalExpressionInYield";
    }

    static TParseTree AssignmentExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpression")(p);
        }
        else
        {
            if(auto m = tuple(`AssignmentExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpression"), "AssignmentExpression")(p);
                memo[tuple(`AssignmentExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AssignmentExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpression"), "AssignmentExpression")(TParseTree("", false,[], s));
        }
    }
    static string AssignmentExpression(GetName g)
    {
        return "ES6.AssignmentExpression";
    }

    static TParseTree AssignmentExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`AssignmentExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionIn"), "AssignmentExpressionIn")(p);
                memo[tuple(`AssignmentExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AssignmentExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionIn, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionIn, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionIn"), "AssignmentExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string AssignmentExpressionIn(GetName g)
    {
        return "ES6.AssignmentExpressionIn";
    }

    static TParseTree AssignmentExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`AssignmentExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionYield"), "AssignmentExpressionYield")(p);
                memo[tuple(`AssignmentExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AssignmentExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpression, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionYield"), "AssignmentExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string AssignmentExpressionYield(GetName g)
    {
        return "ES6.AssignmentExpressionYield";
    }

    static TParseTree AssignmentExpressionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`AssignmentExpressionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionInYield"), "AssignmentExpressionInYield")(p);
                memo[tuple(`AssignmentExpressionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AssignmentExpressionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentOperator, Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, YieldExpressionIn, Spacing), pegged.peg.wrapAround!(Spacing, ArrowFunctionInYield, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpressionInYield, Spacing)), Spacing)), Spacing)), "ES6.AssignmentExpressionInYield"), "AssignmentExpressionInYield")(TParseTree("", false,[], s));
        }
    }
    static string AssignmentExpressionInYield(GetName g)
    {
        return "ES6.AssignmentExpressionInYield";
    }

    static TParseTree AssignmentOperator(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("+="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("-="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|="), Spacing)), "ES6.AssignmentOperator")(p);
        }
        else
        {
            if(auto m = tuple(`AssignmentOperator`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("+="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("-="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|="), Spacing)), "ES6.AssignmentOperator"), "AssignmentOperator")(p);
                memo[tuple(`AssignmentOperator`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree AssignmentOperator(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("+="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("-="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|="), Spacing)), "ES6.AssignmentOperator")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("=="), Spacing)), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("%="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("+="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("-="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<<="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">>>="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("&="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("^="), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("|="), Spacing)), "ES6.AssignmentOperator"), "AssignmentOperator")(TParseTree("", false,[], s));
        }
    }
    static string AssignmentOperator(GetName g)
    {
        return "ES6.AssignmentOperator";
    }

    static TParseTree Comma(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), "ES6.Comma")(p);
        }
        else
        {
            if(auto m = tuple(`Comma`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), "ES6.Comma"), "Comma")(p);
                memo[tuple(`Comma`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Comma(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), "ES6.Comma")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing), "ES6.Comma"), "Comma")(TParseTree("", false,[], s));
        }
    }
    static string Comma(GetName g)
    {
        return "ES6.Comma";
    }

    static TParseTree Expression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.Expression")(p);
        }
        else
        {
            if(auto m = tuple(`Expression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.Expression"), "Expression")(p);
                memo[tuple(`Expression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Expression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.Expression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing))), "ES6.Expression"), "Expression")(TParseTree("", false,[], s));
        }
    }
    static string Expression(GetName g)
    {
        return "ES6.Expression";
    }

    static TParseTree ExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ExpressionIn"), "ExpressionIn")(p);
                memo[tuple(`ExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing))), "ES6.ExpressionIn"), "ExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionIn(GetName g)
    {
        return "ES6.ExpressionIn";
    }

    static TParseTree ExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ExpressionYield"), "ExpressionYield")(p);
                memo[tuple(`ExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionYield, Spacing)), Spacing))), "ES6.ExpressionYield"), "ExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionYield(GetName g)
    {
        return "ES6.ExpressionYield";
    }

    static TParseTree ExpressionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ExpressionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ExpressionInYield"), "ExpressionInYield")(p);
                memo[tuple(`ExpressionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ExpressionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, Comma, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing))), "ES6.ExpressionInYield"), "ExpressionInYield")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionInYield(GetName g)
    {
        return "ES6.ExpressionInYield";
    }

    static TParseTree Statement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatement, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatement, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatement, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatement, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatement, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.Statement")(p);
        }
        else
        {
            if(auto m = tuple(`Statement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatement, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatement, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatement, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatement, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatement, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.Statement"), "Statement")(p);
                memo[tuple(`Statement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Statement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatement, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatement, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatement, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatement, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatement, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.Statement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatement, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatement, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatement, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatement, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatement, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.Statement"), "Statement")(TParseTree("", false,[], s));
        }
    }
    static string Statement(GetName g)
    {
        return "ES6.Statement";
    }

    static TParseTree StatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`StatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYield"), "StatementYield")(p);
                memo[tuple(`StatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYield"), "StatementYield")(TParseTree("", false,[], s));
        }
    }
    static string StatementYield(GetName g)
    {
        return "ES6.StatementYield";
    }

    static TParseTree StatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementReturn"), "StatementReturn")(p);
                memo[tuple(`StatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatement, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatement, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatement, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatement, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatement, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatement, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementReturn"), "StatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementReturn(GetName g)
    {
        return "ES6.StatementReturn";
    }

    static TParseTree StatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYieldReturn"), "StatementYieldReturn")(p);
                memo[tuple(`StatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BlockStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, VariableStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, EmptyStatement, Spacing), pegged.peg.wrapAround!(Spacing, IfStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, BreakableStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ContinueStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, BreakStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, ReturnStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WithStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, LabelledStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, ThrowStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, TryStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, DebuggerStatement, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionStatementYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)))), "ES6.StatementYieldReturn"), "StatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementYieldReturn(GetName g)
    {
        return "ES6.StatementYieldReturn";
    }

    static TParseTree Declaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationIn, Spacing)), "ES6.Declaration")(p);
        }
        else
        {
            if(auto m = tuple(`Declaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationIn, Spacing)), "ES6.Declaration"), "Declaration")(p);
                memo[tuple(`Declaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Declaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationIn, Spacing)), "ES6.Declaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationIn, Spacing)), "ES6.Declaration"), "Declaration")(TParseTree("", false,[], s));
        }
    }
    static string Declaration(GetName g)
    {
        return "ES6.Declaration";
    }

    static TParseTree DeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationInYield, Spacing)), "ES6.DeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`DeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationInYield, Spacing)), "ES6.DeclarationYield"), "DeclarationYield")(p);
                memo[tuple(`DeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationInYield, Spacing)), "ES6.DeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, HoistableDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, ClassDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, LexicalDeclarationInYield, Spacing)), "ES6.DeclarationYield"), "DeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string DeclarationYield(GetName g)
    {
        return "ES6.DeclarationYield";
    }

    static TParseTree HoistableDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing)), "ES6.HoistableDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`HoistableDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing)), "ES6.HoistableDeclaration"), "HoistableDeclaration")(p);
                memo[tuple(`HoistableDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HoistableDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing)), "ES6.HoistableDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing)), "ES6.HoistableDeclaration"), "HoistableDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string HoistableDeclaration(GetName g)
    {
        return "ES6.HoistableDeclaration";
    }

    static TParseTree HoistableDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing)), "ES6.HoistableDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`HoistableDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing)), "ES6.HoistableDeclarationYield"), "HoistableDeclarationYield")(p);
                memo[tuple(`HoistableDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HoistableDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing)), "ES6.HoistableDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing)), "ES6.HoistableDeclarationYield"), "HoistableDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string HoistableDeclarationYield(GetName g)
    {
        return "ES6.HoistableDeclarationYield";
    }

    static TParseTree HoistableDeclarationDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationDefault, Spacing)), "ES6.HoistableDeclarationDefault")(p);
        }
        else
        {
            if(auto m = tuple(`HoistableDeclarationDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationDefault, Spacing)), "ES6.HoistableDeclarationDefault"), "HoistableDeclarationDefault")(p);
                memo[tuple(`HoistableDeclarationDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HoistableDeclarationDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationDefault, Spacing)), "ES6.HoistableDeclarationDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationDefault, Spacing)), "ES6.HoistableDeclarationDefault"), "HoistableDeclarationDefault")(TParseTree("", false,[], s));
        }
    }
    static string HoistableDeclarationDefault(GetName g)
    {
        return "ES6.HoistableDeclarationDefault";
    }

    static TParseTree HoistableDeclarationYieldDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYieldDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYieldDefault, Spacing)), "ES6.HoistableDeclarationYieldDefault")(p);
        }
        else
        {
            if(auto m = tuple(`HoistableDeclarationYieldDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYieldDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYieldDefault, Spacing)), "ES6.HoistableDeclarationYieldDefault"), "HoistableDeclarationYieldDefault")(p);
                memo[tuple(`HoistableDeclarationYieldDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree HoistableDeclarationYieldDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYieldDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYieldDefault, Spacing)), "ES6.HoistableDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorDeclarationYieldDefault, Spacing), pegged.peg.wrapAround!(Spacing, FunctionDeclarationYieldDefault, Spacing)), "ES6.HoistableDeclarationYieldDefault"), "HoistableDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
    }
    static string HoistableDeclarationYieldDefault(GetName g)
    {
        return "ES6.HoistableDeclarationYieldDefault";
    }

    static TParseTree BreakableStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatement, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatement, Spacing)), "ES6.BreakableStatement")(p);
        }
        else
        {
            if(auto m = tuple(`BreakableStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatement, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatement, Spacing)), "ES6.BreakableStatement"), "BreakableStatement")(p);
                memo[tuple(`BreakableStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakableStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatement, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatement, Spacing)), "ES6.BreakableStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatement, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatement, Spacing)), "ES6.BreakableStatement"), "BreakableStatement")(TParseTree("", false,[], s));
        }
    }
    static string BreakableStatement(GetName g)
    {
        return "ES6.BreakableStatement";
    }

    static TParseTree BreakableStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYield, Spacing)), "ES6.BreakableStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BreakableStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYield, Spacing)), "ES6.BreakableStatementYield"), "BreakableStatementYield")(p);
                memo[tuple(`BreakableStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakableStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYield, Spacing)), "ES6.BreakableStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYield, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYield, Spacing)), "ES6.BreakableStatementYield"), "BreakableStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string BreakableStatementYield(GetName g)
    {
        return "ES6.BreakableStatementYield";
    }

    static TParseTree BreakableStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementReturn, Spacing)), "ES6.BreakableStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BreakableStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementReturn, Spacing)), "ES6.BreakableStatementReturn"), "BreakableStatementReturn")(p);
                memo[tuple(`BreakableStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakableStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementReturn, Spacing)), "ES6.BreakableStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementReturn, Spacing)), "ES6.BreakableStatementReturn"), "BreakableStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string BreakableStatementReturn(GetName g)
    {
        return "ES6.BreakableStatementReturn";
    }

    static TParseTree BreakableStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYieldReturn, Spacing)), "ES6.BreakableStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BreakableStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYieldReturn, Spacing)), "ES6.BreakableStatementYieldReturn"), "BreakableStatementYieldReturn")(p);
                memo[tuple(`BreakableStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakableStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYieldReturn, Spacing)), "ES6.BreakableStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IterationStatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, SwitchStatementYieldReturn, Spacing)), "ES6.BreakableStatementYieldReturn"), "BreakableStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string BreakableStatementYieldReturn(GetName g)
    {
        return "ES6.BreakableStatementYieldReturn";
    }

    static TParseTree BlockStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), "ES6.BlockStatement")(p);
        }
        else
        {
            if(auto m = tuple(`BlockStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), "ES6.BlockStatement"), "BlockStatement")(p);
                memo[tuple(`BlockStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), "ES6.BlockStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), "ES6.BlockStatement"), "BlockStatement")(TParseTree("", false,[], s));
        }
    }
    static string BlockStatement(GetName g)
    {
        return "ES6.BlockStatement";
    }

    static TParseTree BlockStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), "ES6.BlockStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BlockStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), "ES6.BlockStatementYield"), "BlockStatementYield")(p);
                memo[tuple(`BlockStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), "ES6.BlockStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), "ES6.BlockStatementYield"), "BlockStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string BlockStatementYield(GetName g)
    {
        return "ES6.BlockStatementYield";
    }

    static TParseTree BlockStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), "ES6.BlockStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BlockStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), "ES6.BlockStatementReturn"), "BlockStatementReturn")(p);
                memo[tuple(`BlockStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), "ES6.BlockStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), "ES6.BlockStatementReturn"), "BlockStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string BlockStatementReturn(GetName g)
    {
        return "ES6.BlockStatementReturn";
    }

    static TParseTree BlockStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), "ES6.BlockStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BlockStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), "ES6.BlockStatementYieldReturn"), "BlockStatementYieldReturn")(p);
                memo[tuple(`BlockStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), "ES6.BlockStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), "ES6.BlockStatementYieldReturn"), "BlockStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string BlockStatementYieldReturn(GetName g)
    {
        return "ES6.BlockStatementYieldReturn";
    }

    static TParseTree Block(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing)), Spacing), "ES6.Block")(p);
        }
        else
        {
            if(auto m = tuple(`Block`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing)), Spacing), "ES6.Block"), "Block")(p);
                memo[tuple(`Block`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Block(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing)), Spacing), "ES6.Block")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing)), Spacing), "ES6.Block"), "Block")(TParseTree("", false,[], s));
        }
    }
    static string Block(GetName g)
    {
        return "ES6.Block";
    }

    static TParseTree BlockYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing)), Spacing), "ES6.BlockYield")(p);
        }
        else
        {
            if(auto m = tuple(`BlockYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing)), Spacing), "ES6.BlockYield"), "BlockYield")(p);
                memo[tuple(`BlockYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing)), Spacing), "ES6.BlockYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing)), Spacing), "ES6.BlockYield"), "BlockYield")(TParseTree("", false,[], s));
        }
    }
    static string BlockYield(GetName g)
    {
        return "ES6.BlockYield";
    }

    static TParseTree BlockReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), Spacing), "ES6.BlockReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BlockReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), Spacing), "ES6.BlockReturn"), "BlockReturn")(p);
                memo[tuple(`BlockReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), Spacing), "ES6.BlockReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), Spacing), "ES6.BlockReturn"), "BlockReturn")(TParseTree("", false,[], s));
        }
    }
    static string BlockReturn(GetName g)
    {
        return "ES6.BlockReturn";
    }

    static TParseTree BlockYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), Spacing), "ES6.BlockYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`BlockYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), Spacing), "ES6.BlockYieldReturn"), "BlockYieldReturn")(p);
                memo[tuple(`BlockYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BlockYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), Spacing), "ES6.BlockYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), Spacing), "ES6.BlockYieldReturn"), "BlockYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string BlockYieldReturn(GetName g)
    {
        return "ES6.BlockYieldReturn";
    }

    static TParseTree StatementList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), "ES6.StatementList")(p);
        }
        else
        {
            if(auto m = tuple(`StatementList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), "ES6.StatementList"), "StatementList")(p);
                memo[tuple(`StatementList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), "ES6.StatementList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItem, Spacing)), "ES6.StatementList"), "StatementList")(TParseTree("", false,[], s));
        }
    }
    static string StatementList(GetName g)
    {
        return "ES6.StatementList";
    }

    static TParseTree StatementListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYield, Spacing)), "ES6.StatementListYield")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYield, Spacing)), "ES6.StatementListYield"), "StatementListYield")(p);
                memo[tuple(`StatementListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYield, Spacing)), "ES6.StatementListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYield, Spacing)), "ES6.StatementListYield"), "StatementListYield")(TParseTree("", false,[], s));
        }
    }
    static string StatementListYield(GetName g)
    {
        return "ES6.StatementListYield";
    }

    static TParseTree StatementListReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemReturn, Spacing)), "ES6.StatementListReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemReturn, Spacing)), "ES6.StatementListReturn"), "StatementListReturn")(p);
                memo[tuple(`StatementListReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemReturn, Spacing)), "ES6.StatementListReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemReturn, Spacing)), "ES6.StatementListReturn"), "StatementListReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementListReturn(GetName g)
    {
        return "ES6.StatementListReturn";
    }

    static TParseTree StatementListYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYieldReturn, Spacing)), "ES6.StatementListYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYieldReturn, Spacing)), "ES6.StatementListYieldReturn"), "StatementListYieldReturn")(p);
                memo[tuple(`StatementListYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYieldReturn, Spacing)), "ES6.StatementListYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, StatementListItemYieldReturn, Spacing)), "ES6.StatementListYieldReturn"), "StatementListYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementListYieldReturn(GetName g)
    {
        return "ES6.StatementListYieldReturn";
    }

    static TParseTree StatementListItem(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.StatementListItem")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListItem`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.StatementListItem"), "StatementListItem")(p);
                memo[tuple(`StatementListItem`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListItem(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.StatementListItem")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.StatementListItem"), "StatementListItem")(TParseTree("", false,[], s));
        }
    }
    static string StatementListItem(GetName g)
    {
        return "ES6.StatementListItem";
    }

    static TParseTree StatementListItemYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.StatementListItemYield")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListItemYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.StatementListItemYield"), "StatementListItemYield")(p);
                memo[tuple(`StatementListItemYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListItemYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.StatementListItemYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.StatementListItemYield"), "StatementListItemYield")(TParseTree("", false,[], s));
        }
    }
    static string StatementListItemYield(GetName g)
    {
        return "ES6.StatementListItemYield";
    }

    static TParseTree StatementListItemReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.StatementListItemReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListItemReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.StatementListItemReturn"), "StatementListItemReturn")(p);
                memo[tuple(`StatementListItemReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListItemReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.StatementListItemReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, Declaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.StatementListItemReturn"), "StatementListItemReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementListItemReturn(GetName g)
    {
        return "ES6.StatementListItemReturn";
    }

    static TParseTree StatementListItemYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.StatementListItemYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`StatementListItemYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.StatementListItemYieldReturn"), "StatementListItemYieldReturn")(p);
                memo[tuple(`StatementListItemYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StatementListItemYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.StatementListItemYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, DeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.StatementListItemYieldReturn"), "StatementListItemYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string StatementListItemYieldReturn(GetName g)
    {
        return "ES6.StatementListItemYieldReturn";
    }

    static TParseTree LexicalDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingList, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingList, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclaration"), "LexicalDeclaration")(p);
                memo[tuple(`LexicalDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingList, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingList, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclaration"), "LexicalDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string LexicalDeclaration(GetName g)
    {
        return "ES6.LexicalDeclaration";
    }

    static TParseTree LexicalDeclarationIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationIn")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalDeclarationIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationIn"), "LexicalDeclarationIn")(p);
                memo[tuple(`LexicalDeclarationIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalDeclarationIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationIn"), "LexicalDeclarationIn")(TParseTree("", false,[], s));
        }
    }
    static string LexicalDeclarationIn(GetName g)
    {
        return "ES6.LexicalDeclarationIn";
    }

    static TParseTree LexicalDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationYield"), "LexicalDeclarationYield")(p);
                memo[tuple(`LexicalDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationYield"), "LexicalDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string LexicalDeclarationYield(GetName g)
    {
        return "ES6.LexicalDeclarationYield";
    }

    static TParseTree LexicalDeclarationInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationInYield")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalDeclarationInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationInYield"), "LexicalDeclarationInYield")(p);
                memo[tuple(`LexicalDeclarationInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalDeclarationInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, BindingListInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.LexicalDeclarationInYield"), "LexicalDeclarationInYield")(TParseTree("", false,[], s));
        }
    }
    static string LexicalDeclarationInYield(GetName g)
    {
        return "ES6.LexicalDeclarationInYield";
    }

    static TParseTree LetOrConst(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("const"), Spacing)), Spacing), "ES6.LetOrConst")(p);
        }
        else
        {
            if(auto m = tuple(`LetOrConst`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("const"), Spacing)), Spacing), "ES6.LetOrConst"), "LetOrConst")(p);
                memo[tuple(`LetOrConst`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LetOrConst(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("const"), Spacing)), Spacing), "ES6.LetOrConst")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("const"), Spacing)), Spacing), "ES6.LetOrConst"), "LetOrConst")(TParseTree("", false,[], s));
        }
    }
    static string LetOrConst(GetName g)
    {
        return "ES6.LetOrConst";
    }

    static TParseTree BindingList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing)), Spacing))), "ES6.BindingList")(p);
        }
        else
        {
            if(auto m = tuple(`BindingList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing)), Spacing))), "ES6.BindingList"), "BindingList")(p);
                memo[tuple(`BindingList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing)), Spacing))), "ES6.BindingList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBinding, Spacing)), Spacing))), "ES6.BindingList"), "BindingList")(TParseTree("", false,[], s));
        }
    }
    static string BindingList(GetName g)
    {
        return "ES6.BindingList";
    }

    static TParseTree BindingListIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing)), Spacing))), "ES6.BindingListIn")(p);
        }
        else
        {
            if(auto m = tuple(`BindingListIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing)), Spacing))), "ES6.BindingListIn"), "BindingListIn")(p);
                memo[tuple(`BindingListIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingListIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing)), Spacing))), "ES6.BindingListIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingIn, Spacing)), Spacing))), "ES6.BindingListIn"), "BindingListIn")(TParseTree("", false,[], s));
        }
    }
    static string BindingListIn(GetName g)
    {
        return "ES6.BindingListIn";
    }

    static TParseTree BindingListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing)), Spacing))), "ES6.BindingListYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing)), Spacing))), "ES6.BindingListYield"), "BindingListYield")(p);
                memo[tuple(`BindingListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing)), Spacing))), "ES6.BindingListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingYield, Spacing)), Spacing))), "ES6.BindingListYield"), "BindingListYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingListYield(GetName g)
    {
        return "ES6.BindingListYield";
    }

    static TParseTree BindingListInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing)), Spacing))), "ES6.BindingListInYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingListInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing)), Spacing))), "ES6.BindingListInYield"), "BindingListInYield")(p);
                memo[tuple(`BindingListInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingListInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing)), Spacing))), "ES6.BindingListInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, LexicalBindingInYield, Spacing)), Spacing))), "ES6.BindingListInYield"), "BindingListInYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingListInYield(GetName g)
    {
        return "ES6.BindingListInYield";
    }

    static TParseTree LexicalBinding(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.LexicalBinding")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalBinding`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.LexicalBinding"), "LexicalBinding")(p);
                memo[tuple(`LexicalBinding`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalBinding(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.LexicalBinding")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.LexicalBinding"), "LexicalBinding")(TParseTree("", false,[], s));
        }
    }
    static string LexicalBinding(GetName g)
    {
        return "ES6.LexicalBinding";
    }

    static TParseTree LexicalBindingIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.LexicalBindingIn")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalBindingIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.LexicalBindingIn"), "LexicalBindingIn")(p);
                memo[tuple(`LexicalBindingIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalBindingIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.LexicalBindingIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.LexicalBindingIn"), "LexicalBindingIn")(TParseTree("", false,[], s));
        }
    }
    static string LexicalBindingIn(GetName g)
    {
        return "ES6.LexicalBindingIn";
    }

    static TParseTree LexicalBindingYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.LexicalBindingYield")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalBindingYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.LexicalBindingYield"), "LexicalBindingYield")(p);
                memo[tuple(`LexicalBindingYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalBindingYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.LexicalBindingYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.LexicalBindingYield"), "LexicalBindingYield")(TParseTree("", false,[], s));
        }
    }
    static string LexicalBindingYield(GetName g)
    {
        return "ES6.LexicalBindingYield";
    }

    static TParseTree LexicalBindingInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.LexicalBindingInYield")(p);
        }
        else
        {
            if(auto m = tuple(`LexicalBindingInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.LexicalBindingInYield"), "LexicalBindingInYield")(p);
                memo[tuple(`LexicalBindingInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LexicalBindingInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.LexicalBindingInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.LexicalBindingInYield"), "LexicalBindingInYield")(TParseTree("", false,[], s));
        }
    }
    static string LexicalBindingInYield(GetName g)
    {
        return "ES6.LexicalBindingInYield";
    }

    static TParseTree VariableStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListIn, Spacing)), "ES6.VariableStatement")(p);
        }
        else
        {
            if(auto m = tuple(`VariableStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListIn, Spacing)), "ES6.VariableStatement"), "VariableStatement")(p);
                memo[tuple(`VariableStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListIn, Spacing)), "ES6.VariableStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListIn, Spacing)), "ES6.VariableStatement"), "VariableStatement")(TParseTree("", false,[], s));
        }
    }
    static string VariableStatement(GetName g)
    {
        return "ES6.VariableStatement";
    }

    static TParseTree VariableStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListInYield, Spacing)), "ES6.VariableStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`VariableStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListInYield, Spacing)), "ES6.VariableStatementYield"), "VariableStatementYield")(p);
                memo[tuple(`VariableStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListInYield, Spacing)), "ES6.VariableStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationListInYield, Spacing)), "ES6.VariableStatementYield"), "VariableStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string VariableStatementYield(GetName g)
    {
        return "ES6.VariableStatementYield";
    }

    static TParseTree VariableDeclarationList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing)), Spacing))), "ES6.VariableDeclarationList")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing)), Spacing))), "ES6.VariableDeclarationList"), "VariableDeclarationList")(p);
                memo[tuple(`VariableDeclarationList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing)), Spacing))), "ES6.VariableDeclarationList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclaration, Spacing)), Spacing))), "ES6.VariableDeclarationList"), "VariableDeclarationList")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationList(GetName g)
    {
        return "ES6.VariableDeclarationList";
    }

    static TParseTree VariableDeclarationListIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing)), Spacing))), "ES6.VariableDeclarationListIn")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationListIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing)), Spacing))), "ES6.VariableDeclarationListIn"), "VariableDeclarationListIn")(p);
                memo[tuple(`VariableDeclarationListIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationListIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing)), Spacing))), "ES6.VariableDeclarationListIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationIn, Spacing)), Spacing))), "ES6.VariableDeclarationListIn"), "VariableDeclarationListIn")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationListIn(GetName g)
    {
        return "ES6.VariableDeclarationListIn";
    }

    static TParseTree VariableDeclarationListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing)), Spacing))), "ES6.VariableDeclarationListYield")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing)), Spacing))), "ES6.VariableDeclarationListYield"), "VariableDeclarationListYield")(p);
                memo[tuple(`VariableDeclarationListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing)), Spacing))), "ES6.VariableDeclarationListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationYield, Spacing)), Spacing))), "ES6.VariableDeclarationListYield"), "VariableDeclarationListYield")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationListYield(GetName g)
    {
        return "ES6.VariableDeclarationListYield";
    }

    static TParseTree VariableDeclarationListInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing)), Spacing))), "ES6.VariableDeclarationListInYield")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationListInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing)), Spacing))), "ES6.VariableDeclarationListInYield"), "VariableDeclarationListInYield")(p);
                memo[tuple(`VariableDeclarationListInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationListInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing)), Spacing))), "ES6.VariableDeclarationListInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, VariableDeclarationInYield, Spacing)), Spacing))), "ES6.VariableDeclarationListInYield"), "VariableDeclarationListInYield")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationListInYield(GetName g)
    {
        return "ES6.VariableDeclarationListInYield";
    }

    static TParseTree VariableDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.VariableDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.VariableDeclaration"), "VariableDeclaration")(p);
                memo[tuple(`VariableDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.VariableDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, Initializer, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Initializer, Spacing))), Spacing)), "ES6.VariableDeclaration"), "VariableDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclaration(GetName g)
    {
        return "ES6.VariableDeclaration";
    }

    static TParseTree VariableDeclarationIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.VariableDeclarationIn")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.VariableDeclarationIn"), "VariableDeclarationIn")(p);
                memo[tuple(`VariableDeclarationIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.VariableDeclarationIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing)), "ES6.VariableDeclarationIn"), "VariableDeclarationIn")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationIn(GetName g)
    {
        return "ES6.VariableDeclarationIn";
    }

    static TParseTree VariableDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.VariableDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.VariableDeclarationYield"), "VariableDeclarationYield")(p);
                memo[tuple(`VariableDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.VariableDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerYield, Spacing))), Spacing)), "ES6.VariableDeclarationYield"), "VariableDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationYield(GetName g)
    {
        return "ES6.VariableDeclarationYield";
    }

    static TParseTree VariableDeclarationInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.VariableDeclarationInYield")(p);
        }
        else
        {
            if(auto m = tuple(`VariableDeclarationInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.VariableDeclarationInYield"), "VariableDeclarationInYield")(p);
                memo[tuple(`VariableDeclarationInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VariableDeclarationInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.VariableDeclarationInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing)), "ES6.VariableDeclarationInYield"), "VariableDeclarationInYield")(TParseTree("", false,[], s));
        }
    }
    static string VariableDeclarationInYield(GetName g)
    {
        return "ES6.VariableDeclarationInYield";
    }

    static TParseTree BindingPattern(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPattern, Spacing)), "ES6.BindingPattern")(p);
        }
        else
        {
            if(auto m = tuple(`BindingPattern`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPattern, Spacing)), "ES6.BindingPattern"), "BindingPattern")(p);
                memo[tuple(`BindingPattern`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingPattern(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPattern, Spacing)), "ES6.BindingPattern")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPattern, Spacing)), "ES6.BindingPattern"), "BindingPattern")(TParseTree("", false,[], s));
        }
    }
    static string BindingPattern(GetName g)
    {
        return "ES6.BindingPattern";
    }

    static TParseTree BindingPatternYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPatternYield, Spacing)), "ES6.BindingPatternYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingPatternYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPatternYield, Spacing)), "ES6.BindingPatternYield"), "BindingPatternYield")(p);
                memo[tuple(`BindingPatternYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingPatternYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPatternYield, Spacing)), "ES6.BindingPatternYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ObjectBindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, ArrayBindingPatternYield, Spacing)), "ES6.BindingPatternYield"), "BindingPatternYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingPatternYield(GetName g)
    {
        return "ES6.BindingPatternYield";
    }

    static TParseTree ObjectBindingPattern(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPattern")(p);
        }
        else
        {
            if(auto m = tuple(`ObjectBindingPattern`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPattern"), "ObjectBindingPattern")(p);
                memo[tuple(`ObjectBindingPattern`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ObjectBindingPattern(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPattern")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPattern"), "ObjectBindingPattern")(TParseTree("", false,[], s));
        }
    }
    static string ObjectBindingPattern(GetName g)
    {
        return "ES6.ObjectBindingPattern";
    }

    static TParseTree ObjectBindingPatternYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPatternYield")(p);
        }
        else
        {
            if(auto m = tuple(`ObjectBindingPatternYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPatternYield"), "ObjectBindingPatternYield")(p);
                memo[tuple(`ObjectBindingPatternYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ObjectBindingPatternYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPatternYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), Spacing))), Spacing))), Spacing), "ES6.ObjectBindingPatternYield"), "ObjectBindingPatternYield")(TParseTree("", false,[], s));
        }
    }
    static string ObjectBindingPatternYield(GetName g)
    {
        return "ES6.ObjectBindingPatternYield";
    }

    static TParseTree ArrayBindingPattern(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing)), Spacing)), "ES6.ArrayBindingPattern")(p);
        }
        else
        {
            if(auto m = tuple(`ArrayBindingPattern`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing)), Spacing)), "ES6.ArrayBindingPattern"), "ArrayBindingPattern")(p);
                memo[tuple(`ArrayBindingPattern`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrayBindingPattern(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing)), Spacing)), "ES6.ArrayBindingPattern")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementList, Spacing)), Spacing)), "ES6.ArrayBindingPattern"), "ArrayBindingPattern")(TParseTree("", false,[], s));
        }
    }
    static string ArrayBindingPattern(GetName g)
    {
        return "ES6.ArrayBindingPattern";
    }

    static TParseTree ArrayBindingPatternYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing)), Spacing)), "ES6.ArrayBindingPatternYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrayBindingPatternYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing)), Spacing)), "ES6.ArrayBindingPatternYield"), "ArrayBindingPatternYield")(p);
                memo[tuple(`ArrayBindingPatternYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrayBindingPatternYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing)), Spacing)), "ES6.ArrayBindingPatternYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing))), Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, SquareBrackets!(pegged.peg.wrapAround!(Spacing, BindingElementListYield, Spacing)), Spacing)), "ES6.ArrayBindingPatternYield"), "ArrayBindingPatternYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrayBindingPatternYield(GetName g)
    {
        return "ES6.ArrayBindingPatternYield";
    }

    static TParseTree BindingPropertyList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing)), Spacing))), "ES6.BindingPropertyList")(p);
        }
        else
        {
            if(auto m = tuple(`BindingPropertyList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing)), Spacing))), "ES6.BindingPropertyList"), "BindingPropertyList")(p);
                memo[tuple(`BindingPropertyList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingPropertyList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing)), Spacing))), "ES6.BindingPropertyList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingProperty, Spacing)), Spacing))), "ES6.BindingPropertyList"), "BindingPropertyList")(TParseTree("", false,[], s));
        }
    }
    static string BindingPropertyList(GetName g)
    {
        return "ES6.BindingPropertyList";
    }

    static TParseTree BindingPropertyListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing)), Spacing))), "ES6.BindingPropertyListYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingPropertyListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing)), Spacing))), "ES6.BindingPropertyListYield"), "BindingPropertyListYield")(p);
                memo[tuple(`BindingPropertyListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingPropertyListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing)), Spacing))), "ES6.BindingPropertyListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingPropertyYield, Spacing)), Spacing))), "ES6.BindingPropertyListYield"), "BindingPropertyListYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingPropertyListYield(GetName g)
    {
        return "ES6.BindingPropertyListYield";
    }

    static TParseTree BindingElementList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing)), Spacing))), "ES6.BindingElementList")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElementList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing)), Spacing))), "ES6.BindingElementList"), "BindingElementList")(p);
                memo[tuple(`BindingElementList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElementList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing)), Spacing))), "ES6.BindingElementList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElement, Spacing)), Spacing))), "ES6.BindingElementList"), "BindingElementList")(TParseTree("", false,[], s));
        }
    }
    static string BindingElementList(GetName g)
    {
        return "ES6.BindingElementList";
    }

    static TParseTree BindingElementListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing)), Spacing))), "ES6.BindingElementListYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElementListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing)), Spacing))), "ES6.BindingElementListYield"), "BindingElementListYield")(p);
                memo[tuple(`BindingElementListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElementListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing)), Spacing))), "ES6.BindingElementListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, BindingElisionElementYield, Spacing)), Spacing))), "ES6.BindingElementListYield"), "BindingElementListYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingElementListYield(GetName g)
    {
        return "ES6.BindingElementListYield";
    }

    static TParseTree BindingElisionElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), "ES6.BindingElisionElement")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElisionElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), "ES6.BindingElisionElement"), "BindingElisionElement")(p);
                memo[tuple(`BindingElisionElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElisionElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), "ES6.BindingElisionElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), "ES6.BindingElisionElement"), "BindingElisionElement")(TParseTree("", false,[], s));
        }
    }
    static string BindingElisionElement(GetName g)
    {
        return "ES6.BindingElisionElement";
    }

    static TParseTree BindingElisionElementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), "ES6.BindingElisionElementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElisionElementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), "ES6.BindingElisionElementYield"), "BindingElisionElementYield")(p);
                memo[tuple(`BindingElisionElementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElisionElementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), "ES6.BindingElisionElementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Elision, Spacing)), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), "ES6.BindingElisionElementYield"), "BindingElisionElementYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingElisionElementYield(GetName g)
    {
        return "ES6.BindingElisionElementYield";
    }

    static TParseTree BindingProperty(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingProperty")(p);
        }
        else
        {
            if(auto m = tuple(`BindingProperty`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingProperty"), "BindingProperty")(p);
                memo[tuple(`BindingProperty`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingProperty(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingProperty")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingProperty"), "BindingProperty")(TParseTree("", false,[], s));
        }
    }
    static string BindingProperty(GetName g)
    {
        return "ES6.BindingProperty";
    }

    static TParseTree BindingPropertyYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingPropertyYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingPropertyYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingPropertyYield"), "BindingPropertyYield")(p);
                memo[tuple(`BindingPropertyYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingPropertyYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingPropertyYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing), pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingPropertyYield"), "BindingPropertyYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingPropertyYield(GetName g)
    {
        return "ES6.BindingPropertyYield";
    }

    static TParseTree BindingElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingElement")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingElement"), "BindingElement")(p);
                memo[tuple(`BindingElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBinding, Spacing)), "ES6.BindingElement"), "BindingElement")(TParseTree("", false,[], s));
        }
    }
    static string BindingElement(GetName g)
    {
        return "ES6.BindingElement";
    }

    static TParseTree BindingElementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingElementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingElementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingElementYield"), "BindingElementYield")(p);
                memo[tuple(`BindingElementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingElementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingElementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, SingleNameBindingYield, Spacing)), "ES6.BindingElementYield"), "BindingElementYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingElementYield(GetName g)
    {
        return "ES6.BindingElementYield";
    }

    static TParseTree SingleNameBinding(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), "ES6.SingleNameBinding")(p);
        }
        else
        {
            if(auto m = tuple(`SingleNameBinding`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), "ES6.SingleNameBinding"), "SingleNameBinding")(p);
                memo[tuple(`SingleNameBinding`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleNameBinding(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), "ES6.SingleNameBinding")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerIn, Spacing))), "ES6.SingleNameBinding"), "SingleNameBinding")(TParseTree("", false,[], s));
        }
    }
    static string SingleNameBinding(GetName g)
    {
        return "ES6.SingleNameBinding";
    }

    static TParseTree SingleNameBindingYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), "ES6.SingleNameBindingYield")(p);
        }
        else
        {
            if(auto m = tuple(`SingleNameBindingYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), "ES6.SingleNameBindingYield"), "SingleNameBindingYield")(p);
                memo[tuple(`SingleNameBindingYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SingleNameBindingYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), "ES6.SingleNameBindingYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, InitializerInYield, Spacing))), "ES6.SingleNameBindingYield"), "SingleNameBindingYield")(TParseTree("", false,[], s));
        }
    }
    static string SingleNameBindingYield(GetName g)
    {
        return "ES6.SingleNameBindingYield";
    }

    static TParseTree BindingRestElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.BindingRestElement")(p);
        }
        else
        {
            if(auto m = tuple(`BindingRestElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.BindingRestElement"), "BindingRestElement")(p);
                memo[tuple(`BindingRestElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingRestElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.BindingRestElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.BindingRestElement"), "BindingRestElement")(TParseTree("", false,[], s));
        }
    }
    static string BindingRestElement(GetName g)
    {
        return "ES6.BindingRestElement";
    }

    static TParseTree BindingRestElementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.BindingRestElementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BindingRestElementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.BindingRestElementYield"), "BindingRestElementYield")(p);
                memo[tuple(`BindingRestElementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BindingRestElementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.BindingRestElementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("..."), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.BindingRestElementYield"), "BindingRestElementYield")(TParseTree("", false,[], s));
        }
    }
    static string BindingRestElementYield(GetName g)
    {
        return "ES6.BindingRestElementYield";
    }

    static TParseTree EmptyStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.EmptyStatement")(p);
        }
        else
        {
            if(auto m = tuple(`EmptyStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.EmptyStatement"), "EmptyStatement")(p);
                memo[tuple(`EmptyStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree EmptyStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.EmptyStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.EmptyStatement"), "EmptyStatement")(TParseTree("", false,[], s));
        }
    }
    static string EmptyStatement(GetName g)
    {
        return "ES6.EmptyStatement";
    }

    static TParseTree ExpressionStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.ExpressionStatement")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.ExpressionStatement"), "ExpressionStatement")(p);
                memo[tuple(`ExpressionStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.ExpressionStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), "ES6.ExpressionStatement"), "ExpressionStatement")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionStatement(GetName g)
    {
        return "ES6.ExpressionStatement";
    }

    static TParseTree ExpressionStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.ExpressionStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`ExpressionStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.ExpressionStatementYield"), "ExpressionStatementYield")(p);
                memo[tuple(`ExpressionStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ExpressionStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.ExpressionStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("class"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), Spacing), pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, IdentifierStart, Spacing), pegged.peg.wrapAround!(Spacing, IdentifierPart, Spacing)), Spacing))), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), "ES6.ExpressionStatementYield"), "ExpressionStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string ExpressionStatementYield(GetName g)
    {
        return "ES6.ExpressionStatementYield";
    }

    static TParseTree ElseKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("else"), Spacing), "ES6.ElseKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`ElseKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("else"), Spacing), "ES6.ElseKeyword"), "ElseKeyword")(p);
                memo[tuple(`ElseKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ElseKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("else"), Spacing), "ES6.ElseKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("else"), Spacing), "ES6.ElseKeyword"), "ElseKeyword")(TParseTree("", false,[], s));
        }
    }
    static string ElseKeyword(GetName g)
    {
        return "ES6.ElseKeyword";
    }

    static TParseTree IfStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing))), "ES6.IfStatement")(p);
        }
        else
        {
            if(auto m = tuple(`IfStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing))), "ES6.IfStatement"), "IfStatement")(p);
                memo[tuple(`IfStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IfStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing))), "ES6.IfStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing))), "ES6.IfStatement"), "IfStatement")(TParseTree("", false,[], s));
        }
    }
    static string IfStatement(GetName g)
    {
        return "ES6.IfStatement";
    }

    static TParseTree IfStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing))), "ES6.IfStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`IfStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing))), "ES6.IfStatementYield"), "IfStatementYield")(p);
                memo[tuple(`IfStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IfStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing))), "ES6.IfStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing))), "ES6.IfStatementYield"), "IfStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string IfStatementYield(GetName g)
    {
        return "ES6.IfStatementYield";
    }

    static TParseTree IfStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing))), "ES6.IfStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`IfStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing))), "ES6.IfStatementReturn"), "IfStatementReturn")(p);
                memo[tuple(`IfStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IfStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing))), "ES6.IfStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing))), "ES6.IfStatementReturn"), "IfStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string IfStatementReturn(GetName g)
    {
        return "ES6.IfStatementReturn";
    }

    static TParseTree IfStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing))), "ES6.IfStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`IfStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing))), "ES6.IfStatementYieldReturn"), "IfStatementYieldReturn")(p);
                memo[tuple(`IfStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IfStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing))), "ES6.IfStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("if"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ElseKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing))), "ES6.IfStatementYieldReturn"), "IfStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string IfStatementYieldReturn(GetName g)
    {
        return "ES6.IfStatementYieldReturn";
    }

    static TParseTree DoKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("do"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.DoKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`DoKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("do"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.DoKeyword"), "DoKeyword")(p);
                memo[tuple(`DoKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DoKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("do"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.DoKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("do"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart))), "ES6.DoKeyword"), "DoKeyword")(TParseTree("", false,[], s));
        }
    }
    static string DoKeyword(GetName g)
    {
        return "ES6.DoKeyword";
    }

    static TParseTree WhileKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("while"), Spacing), "ES6.WhileKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`WhileKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("while"), Spacing), "ES6.WhileKeyword"), "WhileKeyword")(p);
                memo[tuple(`WhileKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WhileKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("while"), Spacing), "ES6.WhileKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("while"), Spacing), "ES6.WhileKeyword"), "WhileKeyword")(TParseTree("", false,[], s));
        }
    }
    static string WhileKeyword(GetName g)
    {
        return "ES6.WhileKeyword";
    }

    static TParseTree ForKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("for"), Spacing), "ES6.ForKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`ForKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("for"), Spacing), "ES6.ForKeyword"), "ForKeyword")(p);
                memo[tuple(`ForKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ForKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("for"), Spacing), "ES6.ForKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("for"), Spacing), "ES6.ForKeyword"), "ForKeyword")(TParseTree("", false,[], s));
        }
    }
    static string ForKeyword(GetName g)
    {
        return "ES6.ForKeyword";
    }

    static TParseTree VarKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing), "ES6.VarKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`VarKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing), "ES6.VarKeyword"), "VarKeyword")(p);
                memo[tuple(`VarKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree VarKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing), "ES6.VarKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("var"), Spacing), "ES6.VarKeyword"), "VarKeyword")(TParseTree("", false,[], s));
        }
    }
    static string VarKeyword(GetName g)
    {
        return "ES6.VarKeyword";
    }

    static TParseTree InKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing), "ES6.InKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`InKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing), "ES6.InKeyword"), "InKeyword")(p);
                memo[tuple(`InKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree InKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing), "ES6.InKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("in"), Spacing), "ES6.InKeyword"), "InKeyword")(TParseTree("", false,[], s));
        }
    }
    static string InKeyword(GetName g)
    {
        return "ES6.InKeyword";
    }

    static TParseTree OfKeyword(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("of"), Spacing), "ES6.OfKeyword")(p);
        }
        else
        {
            if(auto m = tuple(`OfKeyword`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("of"), Spacing), "ES6.OfKeyword"), "OfKeyword")(p);
                memo[tuple(`OfKeyword`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree OfKeyword(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("of"), Spacing), "ES6.OfKeyword")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("of"), Spacing), "ES6.OfKeyword"), "OfKeyword")(TParseTree("", false,[], s));
        }
    }
    static string OfKeyword(GetName g)
    {
        return "ES6.OfKeyword";
    }

    static TParseTree Semicolon(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.Semicolon")(p);
        }
        else
        {
            if(auto m = tuple(`Semicolon`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.Semicolon"), "Semicolon")(p);
                memo[tuple(`Semicolon`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Semicolon(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.Semicolon")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing), "ES6.Semicolon"), "Semicolon")(TParseTree("", false,[], s));
        }
    }
    static string Semicolon(GetName g)
    {
        return "ES6.Semicolon";
    }

    static TParseTree IterationStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing)), "ES6.IterationStatement")(p);
        }
        else
        {
            if(auto m = tuple(`IterationStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing)), "ES6.IterationStatement"), "IterationStatement")(p);
                memo[tuple(`IterationStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IterationStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing)), "ES6.IterationStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), Spacing)), "ES6.IterationStatement"), "IterationStatement")(TParseTree("", false,[], s));
        }
    }
    static string IterationStatement(GetName g)
    {
        return "ES6.IterationStatement";
    }

    static TParseTree IterationStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing)), "ES6.IterationStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`IterationStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing)), "ES6.IterationStatementYield"), "IterationStatementYield")(p);
                memo[tuple(`IterationStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IterationStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing)), "ES6.IterationStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), Spacing)), "ES6.IterationStatementYield"), "IterationStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string IterationStatementYield(GetName g)
    {
        return "ES6.IterationStatementYield";
    }

    static TParseTree IterationStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing)), "ES6.IterationStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`IterationStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing)), "ES6.IterationStatementReturn"), "IterationStatementReturn")(p);
                memo[tuple(`IterationStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IterationStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing)), "ES6.IterationStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationList, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclaration, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Expression, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), Spacing)), "ES6.IterationStatementReturn"), "IterationStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string IterationStatementReturn(GetName g)
    {
        return "ES6.IterationStatementReturn";
    }

    static TParseTree IterationStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing)), "ES6.IterationStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`IterationStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing)), "ES6.IterationStatementYieldReturn"), "IterationStatementYieldReturn")(p);
                memo[tuple(`IterationStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree IterationStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing)), "ES6.IterationStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, DoKeyword, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing), pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, WhileKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, VariableDeclarationListYield, Spacing), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, VarKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing)), Spacing)), Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LexicalDeclarationYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), pegged.peg.wrapAround!(Spacing, Semicolon, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing)), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, InKeyword, Spacing), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, ForKeyword, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("let"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing), pegged.peg.wrapAround!(Spacing, OfKeyword, Spacing), pegged.peg.wrapAround!(Spacing, AssignmentExpressionInYield, Spacing))), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), Spacing)), "ES6.IterationStatementYieldReturn"), "IterationStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string IterationStatementYieldReturn(GetName g)
    {
        return "ES6.IterationStatementYieldReturn";
    }

    static TParseTree ForDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing)), "ES6.ForDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`ForDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing)), "ES6.ForDeclaration"), "ForDeclaration")(p);
                memo[tuple(`ForDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ForDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing)), "ES6.ForDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBinding, Spacing)), "ES6.ForDeclaration"), "ForDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string ForDeclaration(GetName g)
    {
        return "ES6.ForDeclaration";
    }

    static TParseTree ForDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing)), "ES6.ForDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`ForDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing)), "ES6.ForDeclarationYield"), "ForDeclarationYield")(p);
                memo[tuple(`ForDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ForDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing)), "ES6.ForDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LetOrConst, Spacing), pegged.peg.wrapAround!(Spacing, ForBindingYield, Spacing)), "ES6.ForDeclarationYield"), "ForDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string ForDeclarationYield(GetName g)
    {
        return "ES6.ForDeclarationYield";
    }

    static TParseTree ForBinding(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.ForBinding")(p);
        }
        else
        {
            if(auto m = tuple(`ForBinding`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.ForBinding"), "ForBinding")(p);
                memo[tuple(`ForBinding`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ForBinding(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.ForBinding")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.ForBinding"), "ForBinding")(TParseTree("", false,[], s));
        }
    }
    static string ForBinding(GetName g)
    {
        return "ES6.ForBinding";
    }

    static TParseTree ForBindingYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.ForBindingYield")(p);
        }
        else
        {
            if(auto m = tuple(`ForBindingYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.ForBindingYield"), "ForBindingYield")(p);
                memo[tuple(`ForBindingYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ForBindingYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.ForBindingYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.ForBindingYield"), "ForBindingYield")(TParseTree("", false,[], s));
        }
    }
    static string ForBindingYield(GetName g)
    {
        return "ES6.ForBindingYield";
    }

    static TParseTree ContinueStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatement")(p);
        }
        else
        {
            if(auto m = tuple(`ContinueStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatement"), "ContinueStatement")(p);
                memo[tuple(`ContinueStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ContinueStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatement"), "ContinueStatement")(TParseTree("", false,[], s));
        }
    }
    static string ContinueStatement(GetName g)
    {
        return "ES6.ContinueStatement";
    }

    static TParseTree ContinueStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`ContinueStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatementYield"), "ContinueStatementYield")(p);
                memo[tuple(`ContinueStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ContinueStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("continue"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ContinueStatementYield"), "ContinueStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string ContinueStatementYield(GetName g)
    {
        return "ES6.ContinueStatementYield";
    }

    static TParseTree BreakStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatement")(p);
        }
        else
        {
            if(auto m = tuple(`BreakStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatement"), "BreakStatement")(p);
                memo[tuple(`BreakStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifier), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatement"), "BreakStatement")(TParseTree("", false,[], s));
        }
    }
    static string BreakStatement(GetName g)
    {
        return "ES6.BreakStatement";
    }

    static TParseTree BreakStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`BreakStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatementYield"), "BreakStatementYield")(p);
                memo[tuple(`BreakStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree BreakStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(IdentifierStart), Spaces, LabelIdentifierYield), pegged.peg.and!(pegged.peg.literal!("break"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.BreakStatementYield"), "BreakStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string BreakStatementYield(GetName g)
    {
        return "ES6.BreakStatementYield";
    }

    static TParseTree ReturnStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatement")(p);
        }
        else
        {
            if(auto m = tuple(`ReturnStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatement"), "ReturnStatement")(p);
                memo[tuple(`ReturnStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ReturnStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatement"), "ReturnStatement")(TParseTree("", false,[], s));
        }
    }
    static string ReturnStatement(GetName g)
    {
        return "ES6.ReturnStatement";
    }

    static TParseTree ReturnStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`ReturnStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatementYield"), "ReturnStatementYield")(p);
                memo[tuple(`ReturnStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ReturnStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield), pegged.peg.and!(pegged.peg.literal!("return"), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)))), Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ReturnStatementYield"), "ReturnStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string ReturnStatementYield(GetName g)
    {
        return "ES6.ReturnStatementYield";
    }

    static TParseTree WithStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.WithStatement")(p);
        }
        else
        {
            if(auto m = tuple(`WithStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.WithStatement"), "WithStatement")(p);
                memo[tuple(`WithStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WithStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.WithStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.WithStatement"), "WithStatement")(TParseTree("", false,[], s));
        }
    }
    static string WithStatement(GetName g)
    {
        return "ES6.WithStatement";
    }

    static TParseTree WithStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.WithStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`WithStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.WithStatementYield"), "WithStatementYield")(p);
                memo[tuple(`WithStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WithStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.WithStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.WithStatementYield"), "WithStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string WithStatementYield(GetName g)
    {
        return "ES6.WithStatementYield";
    }

    static TParseTree WithStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.WithStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`WithStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.WithStatementReturn"), "WithStatementReturn")(p);
                memo[tuple(`WithStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WithStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.WithStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.WithStatementReturn"), "WithStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string WithStatementReturn(GetName g)
    {
        return "ES6.WithStatementReturn";
    }

    static TParseTree WithStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.WithStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`WithStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.WithStatementYieldReturn"), "WithStatementYieldReturn")(p);
                memo[tuple(`WithStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree WithStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.WithStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("with"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.WithStatementYieldReturn"), "WithStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string WithStatementYieldReturn(GetName g)
    {
        return "ES6.WithStatementYieldReturn";
    }

    static TParseTree SwitchStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlock, Spacing)), "ES6.SwitchStatement")(p);
        }
        else
        {
            if(auto m = tuple(`SwitchStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlock, Spacing)), "ES6.SwitchStatement"), "SwitchStatement")(p);
                memo[tuple(`SwitchStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SwitchStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlock, Spacing)), "ES6.SwitchStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlock, Spacing)), "ES6.SwitchStatement"), "SwitchStatement")(TParseTree("", false,[], s));
        }
    }
    static string SwitchStatement(GetName g)
    {
        return "ES6.SwitchStatement";
    }

    static TParseTree SwitchStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYield, Spacing)), "ES6.SwitchStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`SwitchStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYield, Spacing)), "ES6.SwitchStatementYield"), "SwitchStatementYield")(p);
                memo[tuple(`SwitchStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SwitchStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYield, Spacing)), "ES6.SwitchStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYield, Spacing)), "ES6.SwitchStatementYield"), "SwitchStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string SwitchStatementYield(GetName g)
    {
        return "ES6.SwitchStatementYield";
    }

    static TParseTree SwitchStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockReturn, Spacing)), "ES6.SwitchStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`SwitchStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockReturn, Spacing)), "ES6.SwitchStatementReturn"), "SwitchStatementReturn")(p);
                memo[tuple(`SwitchStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SwitchStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockReturn, Spacing)), "ES6.SwitchStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockReturn, Spacing)), "ES6.SwitchStatementReturn"), "SwitchStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string SwitchStatementReturn(GetName g)
    {
        return "ES6.SwitchStatementReturn";
    }

    static TParseTree SwitchStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYieldReturn, Spacing)), "ES6.SwitchStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`SwitchStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYieldReturn, Spacing)), "ES6.SwitchStatementYieldReturn"), "SwitchStatementYieldReturn")(p);
                memo[tuple(`SwitchStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SwitchStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYieldReturn, Spacing)), "ES6.SwitchStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("switch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CaseBlockYieldReturn, Spacing)), "ES6.SwitchStatementYieldReturn"), "SwitchStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string SwitchStatementYieldReturn(GetName g)
    {
        return "ES6.SwitchStatementYieldReturn";
    }

    static TParseTree CaseBlock(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClause, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)))), Spacing), "ES6.CaseBlock")(p);
        }
        else
        {
            if(auto m = tuple(`CaseBlock`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClause, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)))), Spacing), "ES6.CaseBlock"), "CaseBlock")(p);
                memo[tuple(`CaseBlock`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseBlock(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClause, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)))), Spacing), "ES6.CaseBlock")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClause, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClauses, Spacing)))), Spacing), "ES6.CaseBlock"), "CaseBlock")(TParseTree("", false,[], s));
        }
    }
    static string CaseBlock(GetName g)
    {
        return "ES6.CaseBlock";
    }

    static TParseTree CaseBlockYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)))), Spacing), "ES6.CaseBlockYield")(p);
        }
        else
        {
            if(auto m = tuple(`CaseBlockYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)))), Spacing), "ES6.CaseBlockYield"), "CaseBlockYield")(p);
                memo[tuple(`CaseBlockYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseBlockYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)))), Spacing), "ES6.CaseBlockYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYield, Spacing)))), Spacing), "ES6.CaseBlockYield"), "CaseBlockYield")(TParseTree("", false,[], s));
        }
    }
    static string CaseBlockYield(GetName g)
    {
        return "ES6.CaseBlockYield";
    }

    static TParseTree CaseBlockReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)))), Spacing), "ES6.CaseBlockReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseBlockReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)))), Spacing), "ES6.CaseBlockReturn"), "CaseBlockReturn")(p);
                memo[tuple(`CaseBlockReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseBlockReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)))), Spacing), "ES6.CaseBlockReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesReturn, Spacing)))), Spacing), "ES6.CaseBlockReturn"), "CaseBlockReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseBlockReturn(GetName g)
    {
        return "ES6.CaseBlockReturn";
    }

    static TParseTree CaseBlockYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)))), Spacing), "ES6.CaseBlockYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseBlockYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)))), Spacing), "ES6.CaseBlockYieldReturn"), "CaseBlockYieldReturn")(p);
                memo[tuple(`CaseBlockYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseBlockYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)))), Spacing), "ES6.CaseBlockYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, DefaultClauseYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CaseClausesYieldReturn, Spacing)))), Spacing), "ES6.CaseBlockYieldReturn"), "CaseBlockYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseBlockYieldReturn(GetName g)
    {
        return "ES6.CaseBlockYieldReturn";
    }

    static TParseTree CaseClauses(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClause, Spacing)), "ES6.CaseClauses")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClauses`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClause, Spacing)), "ES6.CaseClauses"), "CaseClauses")(p);
                memo[tuple(`CaseClauses`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClauses(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClause, Spacing)), "ES6.CaseClauses")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClause, Spacing)), "ES6.CaseClauses"), "CaseClauses")(TParseTree("", false,[], s));
        }
    }
    static string CaseClauses(GetName g)
    {
        return "ES6.CaseClauses";
    }

    static TParseTree CaseClausesYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYield, Spacing)), "ES6.CaseClausesYield")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClausesYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYield, Spacing)), "ES6.CaseClausesYield"), "CaseClausesYield")(p);
                memo[tuple(`CaseClausesYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClausesYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYield, Spacing)), "ES6.CaseClausesYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYield, Spacing)), "ES6.CaseClausesYield"), "CaseClausesYield")(TParseTree("", false,[], s));
        }
    }
    static string CaseClausesYield(GetName g)
    {
        return "ES6.CaseClausesYield";
    }

    static TParseTree CaseClausesReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseReturn, Spacing)), "ES6.CaseClausesReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClausesReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseReturn, Spacing)), "ES6.CaseClausesReturn"), "CaseClausesReturn")(p);
                memo[tuple(`CaseClausesReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClausesReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseReturn, Spacing)), "ES6.CaseClausesReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseReturn, Spacing)), "ES6.CaseClausesReturn"), "CaseClausesReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseClausesReturn(GetName g)
    {
        return "ES6.CaseClausesReturn";
    }

    static TParseTree CaseClausesYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYieldReturn, Spacing)), "ES6.CaseClausesYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClausesYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYieldReturn, Spacing)), "ES6.CaseClausesYieldReturn"), "CaseClausesYieldReturn")(p);
                memo[tuple(`CaseClausesYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClausesYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYieldReturn, Spacing)), "ES6.CaseClausesYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, CaseClauseYieldReturn, Spacing)), "ES6.CaseClausesYieldReturn"), "CaseClausesYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseClausesYieldReturn(GetName g)
    {
        return "ES6.CaseClausesYieldReturn";
    }

    static TParseTree CaseClause(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.CaseClause")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClause`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.CaseClause"), "CaseClause")(p);
                memo[tuple(`CaseClause`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClause(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.CaseClause")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.CaseClause"), "CaseClause")(TParseTree("", false,[], s));
        }
    }
    static string CaseClause(GetName g)
    {
        return "ES6.CaseClause";
    }

    static TParseTree CaseClauseYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.CaseClauseYield")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClauseYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.CaseClauseYield"), "CaseClauseYield")(p);
                memo[tuple(`CaseClauseYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClauseYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.CaseClauseYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.CaseClauseYield"), "CaseClauseYield")(TParseTree("", false,[], s));
        }
    }
    static string CaseClauseYield(GetName g)
    {
        return "ES6.CaseClauseYield";
    }

    static TParseTree CaseClauseReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.CaseClauseReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClauseReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.CaseClauseReturn"), "CaseClauseReturn")(p);
                memo[tuple(`CaseClauseReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClauseReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.CaseClauseReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionIn, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.CaseClauseReturn"), "CaseClauseReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseClauseReturn(GetName g)
    {
        return "ES6.CaseClauseReturn";
    }

    static TParseTree CaseClauseYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.CaseClauseYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CaseClauseYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.CaseClauseYieldReturn"), "CaseClauseYieldReturn")(p);
                memo[tuple(`CaseClauseYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CaseClauseYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.CaseClauseYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("case"), Spacing)), pegged.peg.wrapAround!(Spacing, ExpressionInYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.CaseClauseYieldReturn"), "CaseClauseYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string CaseClauseYieldReturn(GetName g)
    {
        return "ES6.CaseClauseYieldReturn";
    }

    static TParseTree DefaultClause(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.DefaultClause")(p);
        }
        else
        {
            if(auto m = tuple(`DefaultClause`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.DefaultClause"), "DefaultClause")(p);
                memo[tuple(`DefaultClause`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DefaultClause(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.DefaultClause")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementList, Spacing))), "ES6.DefaultClause"), "DefaultClause")(TParseTree("", false,[], s));
        }
    }
    static string DefaultClause(GetName g)
    {
        return "ES6.DefaultClause";
    }

    static TParseTree DefaultClauseYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.DefaultClauseYield")(p);
        }
        else
        {
            if(auto m = tuple(`DefaultClauseYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.DefaultClauseYield"), "DefaultClauseYield")(p);
                memo[tuple(`DefaultClauseYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DefaultClauseYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.DefaultClauseYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYield, Spacing))), "ES6.DefaultClauseYield"), "DefaultClauseYield")(TParseTree("", false,[], s));
        }
    }
    static string DefaultClauseYield(GetName g)
    {
        return "ES6.DefaultClauseYield";
    }

    static TParseTree DefaultClauseReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.DefaultClauseReturn")(p);
        }
        else
        {
            if(auto m = tuple(`DefaultClauseReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.DefaultClauseReturn"), "DefaultClauseReturn")(p);
                memo[tuple(`DefaultClauseReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DefaultClauseReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.DefaultClauseReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing))), "ES6.DefaultClauseReturn"), "DefaultClauseReturn")(TParseTree("", false,[], s));
        }
    }
    static string DefaultClauseReturn(GetName g)
    {
        return "ES6.DefaultClauseReturn";
    }

    static TParseTree DefaultClauseYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.DefaultClauseYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`DefaultClauseYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.DefaultClauseYieldReturn"), "DefaultClauseYieldReturn")(p);
                memo[tuple(`DefaultClauseYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DefaultClauseYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.DefaultClauseYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("default"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing))), "ES6.DefaultClauseYieldReturn"), "DefaultClauseYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string DefaultClauseYieldReturn(GetName g)
    {
        return "ES6.DefaultClauseYieldReturn";
    }

    static TParseTree LabelledStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItem, Spacing)), "ES6.LabelledStatement")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItem, Spacing)), "ES6.LabelledStatement"), "LabelledStatement")(p);
                memo[tuple(`LabelledStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItem, Spacing)), "ES6.LabelledStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItem, Spacing)), "ES6.LabelledStatement"), "LabelledStatement")(TParseTree("", false,[], s));
        }
    }
    static string LabelledStatement(GetName g)
    {
        return "ES6.LabelledStatement";
    }

    static TParseTree LabelledStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYield, Spacing)), "ES6.LabelledStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYield, Spacing)), "ES6.LabelledStatementYield"), "LabelledStatementYield")(p);
                memo[tuple(`LabelledStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYield, Spacing)), "ES6.LabelledStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYield, Spacing)), "ES6.LabelledStatementYield"), "LabelledStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string LabelledStatementYield(GetName g)
    {
        return "ES6.LabelledStatementYield";
    }

    static TParseTree LabelledStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemReturn, Spacing)), "ES6.LabelledStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemReturn, Spacing)), "ES6.LabelledStatementReturn"), "LabelledStatementReturn")(p);
                memo[tuple(`LabelledStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemReturn, Spacing)), "ES6.LabelledStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifier, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemReturn, Spacing)), "ES6.LabelledStatementReturn"), "LabelledStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string LabelledStatementReturn(GetName g)
    {
        return "ES6.LabelledStatementReturn";
    }

    static TParseTree LabelledStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYieldReturn, Spacing)), "ES6.LabelledStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYieldReturn, Spacing)), "ES6.LabelledStatementYieldReturn"), "LabelledStatementYieldReturn")(p);
                memo[tuple(`LabelledStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYieldReturn, Spacing)), "ES6.LabelledStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, LabelIdentifierYield, Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(":"), Spacing)), pegged.peg.wrapAround!(Spacing, LabelledItemYieldReturn, Spacing)), "ES6.LabelledStatementYieldReturn"), "LabelledStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string LabelledStatementYieldReturn(GetName g)
    {
        return "ES6.LabelledStatementYieldReturn";
    }

    static TParseTree LabelledItem(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.LabelledItem")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledItem`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.LabelledItem"), "LabelledItem")(p);
                memo[tuple(`LabelledItem`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledItem(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.LabelledItem")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, Statement, Spacing)), "ES6.LabelledItem"), "LabelledItem")(TParseTree("", false,[], s));
        }
    }
    static string LabelledItem(GetName g)
    {
        return "ES6.LabelledItem";
    }

    static TParseTree LabelledItemYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.LabelledItemYield")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledItemYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.LabelledItemYield"), "LabelledItemYield")(p);
                memo[tuple(`LabelledItemYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledItemYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.LabelledItemYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYield, Spacing)), "ES6.LabelledItemYield"), "LabelledItemYield")(TParseTree("", false,[], s));
        }
    }
    static string LabelledItemYield(GetName g)
    {
        return "ES6.LabelledItemYield";
    }

    static TParseTree LabelledItemReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.LabelledItemReturn")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledItemReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.LabelledItemReturn"), "LabelledItemReturn")(p);
                memo[tuple(`LabelledItemReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledItemReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.LabelledItemReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclaration, Spacing), pegged.peg.wrapAround!(Spacing, StatementReturn, Spacing)), "ES6.LabelledItemReturn"), "LabelledItemReturn")(TParseTree("", false,[], s));
        }
    }
    static string LabelledItemReturn(GetName g)
    {
        return "ES6.LabelledItemReturn";
    }

    static TParseTree LabelledItemYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.LabelledItemYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`LabelledItemYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.LabelledItemYieldReturn"), "LabelledItemYieldReturn")(p);
                memo[tuple(`LabelledItemYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree LabelledItemYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.LabelledItemYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionDeclarationYield, Spacing), pegged.peg.wrapAround!(Spacing, StatementYieldReturn, Spacing)), "ES6.LabelledItemYieldReturn"), "LabelledItemYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string LabelledItemYieldReturn(GetName g)
    {
        return "ES6.LabelledItemYieldReturn";
    }

    static TParseTree ThrowStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatement")(p);
        }
        else
        {
            if(auto m = tuple(`ThrowStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatement"), "ThrowStatement")(p);
                memo[tuple(`ThrowStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ThrowStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionIn, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatement"), "ThrowStatement")(TParseTree("", false,[], s));
        }
    }
    static string ThrowStatement(GetName g)
    {
        return "ES6.ThrowStatement";
    }

    static TParseTree ThrowStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`ThrowStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatementYield"), "ThrowStatementYield")(p);
                memo[tuple(`ThrowStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ThrowStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.literal!("throw"), pegged.peg.negLookahead!(IdentifierStart), Spaces, ExpressionInYield, Spaces, pegged.peg.discard!(pegged.peg.option!(pegged.peg.literal!(";")))), "ES6.ThrowStatementYield"), "ThrowStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string ThrowStatementYield(GetName g)
    {
        return "ES6.ThrowStatementYield";
    }

    static TParseTree TryStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Catch, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Finally, Spacing))), "ES6.TryStatement")(p);
        }
        else
        {
            if(auto m = tuple(`TryStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Catch, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Finally, Spacing))), "ES6.TryStatement"), "TryStatement")(p);
                memo[tuple(`TryStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TryStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Catch, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Finally, Spacing))), "ES6.TryStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Catch, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, Finally, Spacing))), "ES6.TryStatement"), "TryStatement")(TParseTree("", false,[], s));
        }
    }
    static string TryStatement(GetName g)
    {
        return "ES6.TryStatement";
    }

    static TParseTree TryStatementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYield, Spacing))), "ES6.TryStatementYield")(p);
        }
        else
        {
            if(auto m = tuple(`TryStatementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYield, Spacing))), "ES6.TryStatementYield"), "TryStatementYield")(p);
                memo[tuple(`TryStatementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TryStatementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYield, Spacing))), "ES6.TryStatementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYield, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYield, Spacing))), "ES6.TryStatementYield"), "TryStatementYield")(TParseTree("", false,[], s));
        }
    }
    static string TryStatementYield(GetName g)
    {
        return "ES6.TryStatementYield";
    }

    static TParseTree TryStatementReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyReturn, Spacing))), "ES6.TryStatementReturn")(p);
        }
        else
        {
            if(auto m = tuple(`TryStatementReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyReturn, Spacing))), "ES6.TryStatementReturn"), "TryStatementReturn")(p);
                memo[tuple(`TryStatementReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TryStatementReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyReturn, Spacing))), "ES6.TryStatementReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyReturn, Spacing))), "ES6.TryStatementReturn"), "TryStatementReturn")(TParseTree("", false,[], s));
        }
    }
    static string TryStatementReturn(GetName g)
    {
        return "ES6.TryStatementReturn";
    }

    static TParseTree TryStatementYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYieldReturn, Spacing))), "ES6.TryStatementYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`TryStatementYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYieldReturn, Spacing))), "ES6.TryStatementYieldReturn"), "TryStatementYieldReturn")(p);
                memo[tuple(`TryStatementYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree TryStatementYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYieldReturn, Spacing))), "ES6.TryStatementYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("try"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, CatchYieldReturn, Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FinallyYieldReturn, Spacing))), "ES6.TryStatementYieldReturn"), "TryStatementYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string TryStatementYieldReturn(GetName g)
    {
        return "ES6.TryStatementYieldReturn";
    }

    static TParseTree Catch(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Catch")(p);
        }
        else
        {
            if(auto m = tuple(`Catch`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Catch"), "Catch")(p);
                memo[tuple(`Catch`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Catch(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Catch")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Catch"), "Catch")(TParseTree("", false,[], s));
        }
    }
    static string Catch(GetName g)
    {
        return "ES6.Catch";
    }

    static TParseTree CatchYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.CatchYield")(p);
        }
        else
        {
            if(auto m = tuple(`CatchYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.CatchYield"), "CatchYield")(p);
                memo[tuple(`CatchYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CatchYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.CatchYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.CatchYield"), "CatchYield")(TParseTree("", false,[], s));
        }
    }
    static string CatchYield(GetName g)
    {
        return "ES6.CatchYield";
    }

    static TParseTree CatchReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.CatchReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CatchReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.CatchReturn"), "CatchReturn")(p);
                memo[tuple(`CatchReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CatchReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.CatchReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameter, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.CatchReturn"), "CatchReturn")(TParseTree("", false,[], s));
        }
    }
    static string CatchReturn(GetName g)
    {
        return "ES6.CatchReturn";
    }

    static TParseTree CatchYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.CatchYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`CatchYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.CatchYieldReturn"), "CatchYieldReturn")(p);
                memo[tuple(`CatchYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CatchYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.CatchYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("catch"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, CatchParameterYield, Spacing)), Spacing), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.CatchYieldReturn"), "CatchYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string CatchYieldReturn(GetName g)
    {
        return "ES6.CatchYieldReturn";
    }

    static TParseTree Finally(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Finally")(p);
        }
        else
        {
            if(auto m = tuple(`Finally`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Finally"), "Finally")(p);
                memo[tuple(`Finally`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Finally(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Finally")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, Block, Spacing))), "ES6.Finally"), "Finally")(TParseTree("", false,[], s));
        }
    }
    static string Finally(GetName g)
    {
        return "ES6.Finally";
    }

    static TParseTree FinallyYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.FinallyYield")(p);
        }
        else
        {
            if(auto m = tuple(`FinallyYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.FinallyYield"), "FinallyYield")(p);
                memo[tuple(`FinallyYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FinallyYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.FinallyYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYield, Spacing))), "ES6.FinallyYield"), "FinallyYield")(TParseTree("", false,[], s));
        }
    }
    static string FinallyYield(GetName g)
    {
        return "ES6.FinallyYield";
    }

    static TParseTree FinallyReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.FinallyReturn")(p);
        }
        else
        {
            if(auto m = tuple(`FinallyReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.FinallyReturn"), "FinallyReturn")(p);
                memo[tuple(`FinallyReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FinallyReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.FinallyReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockReturn, Spacing))), "ES6.FinallyReturn"), "FinallyReturn")(TParseTree("", false,[], s));
        }
    }
    static string FinallyReturn(GetName g)
    {
        return "ES6.FinallyReturn";
    }

    static TParseTree FinallyYieldReturn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.FinallyYieldReturn")(p);
        }
        else
        {
            if(auto m = tuple(`FinallyYieldReturn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.FinallyYieldReturn"), "FinallyYieldReturn")(p);
                memo[tuple(`FinallyYieldReturn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FinallyYieldReturn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.FinallyYieldReturn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("finally"), Spacing)), pegged.peg.propagate!(pegged.peg.wrapAround!(Spacing, BlockYieldReturn, Spacing))), "ES6.FinallyYieldReturn"), "FinallyYieldReturn")(TParseTree("", false,[], s));
        }
    }
    static string FinallyYieldReturn(GetName g)
    {
        return "ES6.FinallyYieldReturn";
    }

    static TParseTree CatchParameter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.CatchParameter")(p);
        }
        else
        {
            if(auto m = tuple(`CatchParameter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.CatchParameter"), "CatchParameter")(p);
                memo[tuple(`CatchParameter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CatchParameter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.CatchParameter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPattern, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), "ES6.CatchParameter"), "CatchParameter")(TParseTree("", false,[], s));
        }
    }
    static string CatchParameter(GetName g)
    {
        return "ES6.CatchParameter";
    }

    static TParseTree CatchParameterYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.CatchParameterYield")(p);
        }
        else
        {
            if(auto m = tuple(`CatchParameterYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.CatchParameterYield"), "CatchParameterYield")(p);
                memo[tuple(`CatchParameterYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CatchParameterYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.CatchParameterYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingPatternYield, Spacing), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), "ES6.CatchParameterYield"), "CatchParameterYield")(TParseTree("", false,[], s));
        }
    }
    static string CatchParameterYield(GetName g)
    {
        return "ES6.CatchParameterYield";
    }

    static TParseTree DebuggerStatement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("debugger"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.DebuggerStatement")(p);
        }
        else
        {
            if(auto m = tuple(`DebuggerStatement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("debugger"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.DebuggerStatement"), "DebuggerStatement")(p);
                memo[tuple(`DebuggerStatement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree DebuggerStatement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("debugger"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.DebuggerStatement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("debugger"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing))), "ES6.DebuggerStatement"), "DebuggerStatement")(TParseTree("", false,[], s));
        }
    }
    static string DebuggerStatement(GetName g)
    {
        return "ES6.DebuggerStatement";
    }

    template CurlyBrackets(alias Content)
    {
    static TParseTree CurlyBrackets(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("}"), Spacing)), "ES6.CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")")(p);
        }
        else
        {
            if(auto m = tuple("CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")",p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("}"), Spacing)), "ES6.CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")"), "CurlyBrackets_1")(p);
                memo[tuple("CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")",p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree CurlyBrackets(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("}"), Spacing)), "ES6.CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("}"), Spacing)), "ES6.CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")"), "CurlyBrackets_1")(TParseTree("", false,[], s));
        }
    }
    static string CurlyBrackets(GetName g)
    {
        return "ES6.CurlyBrackets!(" ~ pegged.peg.getName!(Content) ~ ")";
    }

    }
    template Parentheses(alias Content)
    {
    static TParseTree Parentheses(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing)), "ES6.Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")")(p);
        }
        else
        {
            if(auto m = tuple("Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")",p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing)), "ES6.Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")"), "Parentheses_1")(p);
                memo[tuple("Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")",p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree Parentheses(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing)), "ES6.Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing)), "ES6.Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")"), "Parentheses_1")(TParseTree("", false,[], s));
        }
    }
    static string Parentheses(GetName g)
    {
        return "ES6.Parentheses!(" ~ pegged.peg.getName!(Content) ~ ")";
    }

    }
    template SquareBrackets(alias Content)
    {
    static TParseTree SquareBrackets(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("]"), Spacing)), "ES6.SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")")(p);
        }
        else
        {
            if(auto m = tuple("SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")",p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("]"), Spacing)), "ES6.SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")"), "SquareBrackets_1")(p);
                memo[tuple("SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")",p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree SquareBrackets(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("]"), Spacing)), "ES6.SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("["), Spacing), pegged.peg.wrapAround!(Spacing, Content, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("]"), Spacing)), "ES6.SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")"), "SquareBrackets_1")(TParseTree("", false,[], s));
        }
    }
    static string SquareBrackets(GetName g)
    {
        return "ES6.SquareBrackets!(" ~ pegged.peg.getName!(Content) ~ ")";
    }

    }
    static TParseTree FunctionDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclaration"), "FunctionDeclaration")(p);
                memo[tuple(`FunctionDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclaration"), "FunctionDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string FunctionDeclaration(GetName g)
    {
        return "ES6.FunctionDeclaration";
    }

    static TParseTree FunctionDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclarationYield"), "FunctionDeclarationYield")(p);
                memo[tuple(`FunctionDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), "ES6.FunctionDeclarationYield"), "FunctionDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string FunctionDeclarationYield(GetName g)
    {
        return "ES6.FunctionDeclarationYield";
    }

    static TParseTree FunctionDeclarationDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationDefault")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionDeclarationDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationDefault"), "FunctionDeclarationDefault")(p);
                memo[tuple(`FunctionDeclarationDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionDeclarationDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationDefault"), "FunctionDeclarationDefault")(TParseTree("", false,[], s));
        }
    }
    static string FunctionDeclarationDefault(GetName g)
    {
        return "ES6.FunctionDeclarationDefault";
    }

    static TParseTree FunctionDeclarationYieldDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationYieldDefault")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionDeclarationYieldDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationYieldDefault"), "FunctionDeclarationYieldDefault")(p);
                memo[tuple(`FunctionDeclarationYieldDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionDeclarationYieldDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.FunctionDeclarationYieldDefault"), "FunctionDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
    }
    static string FunctionDeclarationYieldDefault(GetName g)
    {
        return "ES6.FunctionDeclarationYieldDefault";
    }

    static TParseTree FunctionExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.FunctionExpression")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.FunctionExpression"), "FunctionExpression")(p);
                memo[tuple(`FunctionExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.FunctionExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.FunctionExpression"), "FunctionExpression")(TParseTree("", false,[], s));
        }
    }
    static string FunctionExpression(GetName g)
    {
        return "ES6.FunctionExpression";
    }

    static TParseTree StrictFormalParameters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing), "ES6.StrictFormalParameters")(p);
        }
        else
        {
            if(auto m = tuple(`StrictFormalParameters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing), "ES6.StrictFormalParameters"), "StrictFormalParameters")(p);
                memo[tuple(`StrictFormalParameters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StrictFormalParameters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing), "ES6.StrictFormalParameters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing), "ES6.StrictFormalParameters"), "StrictFormalParameters")(TParseTree("", false,[], s));
        }
    }
    static string StrictFormalParameters(GetName g)
    {
        return "ES6.StrictFormalParameters";
    }

    static TParseTree StrictFormalParametersYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing), "ES6.StrictFormalParametersYield")(p);
        }
        else
        {
            if(auto m = tuple(`StrictFormalParametersYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing), "ES6.StrictFormalParametersYield"), "StrictFormalParametersYield")(p);
                memo[tuple(`StrictFormalParametersYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree StrictFormalParametersYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing), "ES6.StrictFormalParametersYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing), "ES6.StrictFormalParametersYield"), "StrictFormalParametersYield")(TParseTree("", false,[], s));
        }
    }
    static string StrictFormalParametersYield(GetName g)
    {
        return "ES6.StrictFormalParametersYield";
    }

    static TParseTree FormalParameters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterList, Spacing)), "ES6.FormalParameters")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParameters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterList, Spacing)), "ES6.FormalParameters"), "FormalParameters")(p);
                memo[tuple(`FormalParameters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParameters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterList, Spacing)), "ES6.FormalParameters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterList, Spacing)), "ES6.FormalParameters"), "FormalParameters")(TParseTree("", false,[], s));
        }
    }
    static string FormalParameters(GetName g)
    {
        return "ES6.FormalParameters";
    }

    static TParseTree FormalParametersYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterListYield, Spacing)), "ES6.FormalParametersYield")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParametersYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterListYield, Spacing)), "ES6.FormalParametersYield"), "FormalParametersYield")(p);
                memo[tuple(`FormalParametersYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParametersYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterListYield, Spacing)), "ES6.FormalParametersYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, FormalParameterListYield, Spacing)), "ES6.FormalParametersYield"), "FormalParametersYield")(TParseTree("", false,[], s));
        }
    }
    static string FormalParametersYield(GetName g)
    {
        return "ES6.FormalParametersYield";
    }

    static TParseTree FormalParameterList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterList")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParameterList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterList"), "FormalParameterList")(p);
                memo[tuple(`FormalParameterList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParameterList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsList, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameter, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterList"), "FormalParameterList")(TParseTree("", false,[], s));
        }
    }
    static string FormalParameterList(GetName g)
    {
        return "ES6.FormalParameterList";
    }

    static TParseTree FormalParameterListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterListYield")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParameterListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterListYield"), "FormalParameterListYield")(p);
                memo[tuple(`FormalParameterListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParameterListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalsListYield, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FunctionRestParameterYield, Spacing)), Spacing))), Spacing)), "ES6.FormalParameterListYield"), "FormalParameterListYield")(TParseTree("", false,[], s));
        }
    }
    static string FormalParameterListYield(GetName g)
    {
        return "ES6.FormalParameterListYield";
    }

    static TParseTree FormalsList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing)), Spacing))), "ES6.FormalsList")(p);
        }
        else
        {
            if(auto m = tuple(`FormalsList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing)), Spacing))), "ES6.FormalsList"), "FormalsList")(p);
                memo[tuple(`FormalsList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalsList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing)), Spacing))), "ES6.FormalsList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing)), Spacing))), "ES6.FormalsList"), "FormalsList")(TParseTree("", false,[], s));
        }
    }
    static string FormalsList(GetName g)
    {
        return "ES6.FormalsList";
    }

    static TParseTree FormalsListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing)), Spacing))), "ES6.FormalsListYield")(p);
        }
        else
        {
            if(auto m = tuple(`FormalsListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing)), Spacing))), "ES6.FormalsListYield"), "FormalsListYield")(p);
                memo[tuple(`FormalsListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalsListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing)), Spacing))), "ES6.FormalsListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing), pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(","), Spacing)), pegged.peg.wrapAround!(Spacing, FormalParameterYield, Spacing)), Spacing))), "ES6.FormalsListYield"), "FormalsListYield")(TParseTree("", false,[], s));
        }
    }
    static string FormalsListYield(GetName g)
    {
        return "ES6.FormalsListYield";
    }

    static TParseTree FunctionRestParameter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing), "ES6.FunctionRestParameter")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionRestParameter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing), "ES6.FunctionRestParameter"), "FunctionRestParameter")(p);
                memo[tuple(`FunctionRestParameter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionRestParameter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing), "ES6.FunctionRestParameter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElement, Spacing), "ES6.FunctionRestParameter"), "FunctionRestParameter")(TParseTree("", false,[], s));
        }
    }
    static string FunctionRestParameter(GetName g)
    {
        return "ES6.FunctionRestParameter";
    }

    static TParseTree FunctionRestParameterYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing), "ES6.FunctionRestParameterYield")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionRestParameterYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing), "ES6.FunctionRestParameterYield"), "FunctionRestParameterYield")(p);
                memo[tuple(`FunctionRestParameterYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionRestParameterYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing), "ES6.FunctionRestParameterYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingRestElementYield, Spacing), "ES6.FunctionRestParameterYield"), "FunctionRestParameterYield")(TParseTree("", false,[], s));
        }
    }
    static string FunctionRestParameterYield(GetName g)
    {
        return "ES6.FunctionRestParameterYield";
    }

    static TParseTree FormalParameter(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElement, Spacing), "ES6.FormalParameter")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParameter`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElement, Spacing), "ES6.FormalParameter"), "FormalParameter")(p);
                memo[tuple(`FormalParameter`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParameter(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElement, Spacing), "ES6.FormalParameter")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElement, Spacing), "ES6.FormalParameter"), "FormalParameter")(TParseTree("", false,[], s));
        }
    }
    static string FormalParameter(GetName g)
    {
        return "ES6.FormalParameter";
    }

    static TParseTree FormalParameterYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing), "ES6.FormalParameterYield")(p);
        }
        else
        {
            if(auto m = tuple(`FormalParameterYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing), "ES6.FormalParameterYield"), "FormalParameterYield")(p);
                memo[tuple(`FormalParameterYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FormalParameterYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing), "ES6.FormalParameterYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, BindingElementYield, Spacing), "ES6.FormalParameterYield"), "FormalParameterYield")(TParseTree("", false,[], s));
        }
    }
    static string FormalParameterYield(GetName g)
    {
        return "ES6.FormalParameterYield";
    }

    static TParseTree FunctionBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementList, Spacing), "ES6.FunctionBody")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementList, Spacing), "ES6.FunctionBody"), "FunctionBody")(p);
                memo[tuple(`FunctionBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementList, Spacing), "ES6.FunctionBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementList, Spacing), "ES6.FunctionBody"), "FunctionBody")(TParseTree("", false,[], s));
        }
    }
    static string FunctionBody(GetName g)
    {
        return "ES6.FunctionBody";
    }

    static TParseTree FunctionBodyYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementListYield, Spacing), "ES6.FunctionBodyYield")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionBodyYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementListYield, Spacing), "ES6.FunctionBodyYield"), "FunctionBodyYield")(p);
                memo[tuple(`FunctionBodyYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionBodyYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementListYield, Spacing), "ES6.FunctionBodyYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionStatementListYield, Spacing), "ES6.FunctionBodyYield"), "FunctionBodyYield")(TParseTree("", false,[], s));
        }
    }
    static string FunctionBodyYield(GetName g)
    {
        return "ES6.FunctionBodyYield";
    }

    static TParseTree FunctionStatementList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), "ES6.FunctionStatementList")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionStatementList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), "ES6.FunctionStatementList"), "FunctionStatementList")(p);
                memo[tuple(`FunctionStatementList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionStatementList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), "ES6.FunctionStatementList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListReturn, Spacing)), "ES6.FunctionStatementList"), "FunctionStatementList")(TParseTree("", false,[], s));
        }
    }
    static string FunctionStatementList(GetName g)
    {
        return "ES6.FunctionStatementList";
    }

    static TParseTree FunctionStatementListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), "ES6.FunctionStatementListYield")(p);
        }
        else
        {
            if(auto m = tuple(`FunctionStatementListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), "ES6.FunctionStatementListYield"), "FunctionStatementListYield")(p);
                memo[tuple(`FunctionStatementListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree FunctionStatementListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), "ES6.FunctionStatementListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, StatementListYieldReturn, Spacing)), "ES6.FunctionStatementListYield"), "FunctionStatementListYield")(TParseTree("", false,[], s));
        }
    }
    static string FunctionStatementListYield(GetName g)
    {
        return "ES6.FunctionStatementListYield";
    }

    static TParseTree ArrowFunction(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunction")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFunction`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunction"), "ArrowFunction")(p);
                memo[tuple(`ArrowFunction`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFunction(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunction")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunction"), "ArrowFunction")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFunction(GetName g)
    {
        return "ES6.ArrowFunction";
    }

    static TParseTree ArrowFunctionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionIn")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFunctionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionIn"), "ArrowFunctionIn")(p);
                memo[tuple(`ArrowFunctionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFunctionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParameters, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionIn"), "ArrowFunctionIn")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFunctionIn(GetName g)
    {
        return "ES6.ArrowFunctionIn";
    }

    static TParseTree ArrowFunctionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunctionYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFunctionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunctionYield"), "ArrowFunctionYield")(p);
                memo[tuple(`ArrowFunctionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFunctionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunctionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBody), "ES6.ArrowFunctionYield"), "ArrowFunctionYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFunctionYield(GetName g)
    {
        return "ES6.ArrowFunctionYield";
    }

    static TParseTree ArrowFunctionInYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionInYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFunctionInYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionInYield"), "ArrowFunctionInYield")(p);
                memo[tuple(`ArrowFunctionInYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFunctionInYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionInYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(ArrowParametersYield, Spaces, pegged.peg.literal!("=>"), Spacing, ConciseBodyIn), "ES6.ArrowFunctionInYield"), "ArrowFunctionInYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFunctionInYield(GetName g)
    {
        return "ES6.ArrowFunctionInYield";
    }

    static TParseTree ArrowParameters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing)), "ES6.ArrowParameters")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowParameters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing)), "ES6.ArrowParameters"), "ArrowParameters")(p);
                memo[tuple(`ArrowParameters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowParameters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing)), "ES6.ArrowParameters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterList, Spacing)), "ES6.ArrowParameters"), "ArrowParameters")(TParseTree("", false,[], s));
        }
    }
    static string ArrowParameters(GetName g)
    {
        return "ES6.ArrowParameters";
    }

    static TParseTree ArrowParametersYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing)), "ES6.ArrowParametersYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowParametersYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing)), "ES6.ArrowParametersYield"), "ArrowParametersYield")(p);
                memo[tuple(`ArrowParametersYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowParametersYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing)), "ES6.ArrowParametersYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, CoverParenthesizedExpressionAndArrowParameterListYield, Spacing)), "ES6.ArrowParametersYield"), "ArrowParametersYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrowParametersYield(GetName g)
    {
        return "ES6.ArrowParametersYield";
    }

    static TParseTree ConciseBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBody")(p);
        }
        else
        {
            if(auto m = tuple(`ConciseBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBody"), "ConciseBody")(p);
                memo[tuple(`ConciseBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConciseBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpression, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBody"), "ConciseBody")(TParseTree("", false,[], s));
        }
    }
    static string ConciseBody(GetName g)
    {
        return "ES6.ConciseBody";
    }

    static TParseTree ConciseBodyIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBodyIn")(p);
        }
        else
        {
            if(auto m = tuple(`ConciseBodyIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBodyIn"), "ConciseBodyIn")(p);
                memo[tuple(`ConciseBodyIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ConciseBodyIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBodyIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("{"), Spacing), Spacing)), pegged.peg.wrapAround!(Spacing, AssignmentExpressionIn, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), "ES6.ConciseBodyIn"), "ConciseBodyIn")(TParseTree("", false,[], s));
        }
    }
    static string ConciseBodyIn(GetName g)
    {
        return "ES6.ConciseBodyIn";
    }

    static TParseTree ArrowFormalParameters(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), "ES6.ArrowFormalParameters")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFormalParameters`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), "ES6.ArrowFormalParameters"), "ArrowFormalParameters")(p);
                memo[tuple(`ArrowFormalParameters`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFormalParameters(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), "ES6.ArrowFormalParameters")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), "ES6.ArrowFormalParameters"), "ArrowFormalParameters")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFormalParameters(GetName g)
    {
        return "ES6.ArrowFormalParameters";
    }

    static TParseTree ArrowFormalParametersYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), "ES6.ArrowFormalParametersYield")(p);
        }
        else
        {
            if(auto m = tuple(`ArrowFormalParametersYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), "ES6.ArrowFormalParametersYield"), "ArrowFormalParametersYield")(p);
                memo[tuple(`ArrowFormalParametersYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ArrowFormalParametersYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), "ES6.ArrowFormalParametersYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), "ES6.ArrowFormalParametersYield"), "ArrowFormalParametersYield")(TParseTree("", false,[], s));
        }
    }
    static string ArrowFormalParametersYield(GetName g)
    {
        return "ES6.ArrowFormalParametersYield";
    }

    static TParseTree MethodDefinition(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethod, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinition")(p);
        }
        else
        {
            if(auto m = tuple(`MethodDefinition`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethod, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinition"), "MethodDefinition")(p);
                memo[tuple(`MethodDefinition`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MethodDefinition(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethod, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinition")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethod, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinition"), "MethodDefinition")(TParseTree("", false,[], s));
        }
    }
    static string MethodDefinition(GetName g)
    {
        return "ES6.MethodDefinition";
    }

    static TParseTree MethodDefinitionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethodYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinitionYield")(p);
        }
        else
        {
            if(auto m = tuple(`MethodDefinitionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethodYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinitionYield"), "MethodDefinitionYield")(p);
                memo[tuple(`MethodDefinitionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree MethodDefinitionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethodYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinitionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, GeneratorMethodYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("get"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("("), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(")"), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("set"), Spacing), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, PropertySetParameterList, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, FunctionBody, Spacing)), Spacing)), Spacing)), "ES6.MethodDefinitionYield"), "MethodDefinitionYield")(TParseTree("", false,[], s));
        }
    }
    static string MethodDefinitionYield(GetName g)
    {
        return "ES6.MethodDefinitionYield";
    }

    static TParseTree PropertySetParameterList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), "ES6.PropertySetParameterList")(p);
        }
        else
        {
            if(auto m = tuple(`PropertySetParameterList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), "ES6.PropertySetParameterList"), "PropertySetParameterList")(p);
                memo[tuple(`PropertySetParameterList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree PropertySetParameterList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), "ES6.PropertySetParameterList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FormalParameter, Spacing), "ES6.PropertySetParameterList"), "PropertySetParameterList")(TParseTree("", false,[], s));
        }
    }
    static string PropertySetParameterList(GetName g)
    {
        return "ES6.PropertySetParameterList";
    }

    static TParseTree GeneratorMethod(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethod")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorMethod`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethod"), "GeneratorMethod")(p);
                memo[tuple(`GeneratorMethod`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorMethod(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethod")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyName, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethod"), "GeneratorMethod")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorMethod(GetName g)
    {
        return "ES6.GeneratorMethod";
    }

    static TParseTree GeneratorMethodYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethodYield")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorMethodYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethodYield"), "GeneratorMethodYield")(p);
                memo[tuple(`GeneratorMethodYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorMethodYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethodYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, PropertyNameYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, StrictFormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorMethodYield"), "GeneratorMethodYield")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorMethodYield(GetName g)
    {
        return "ES6.GeneratorMethodYield";
    }

    static TParseTree GeneratorDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclaration"), "GeneratorDeclaration")(p);
                memo[tuple(`GeneratorDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclaration"), "GeneratorDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorDeclaration(GetName g)
    {
        return "ES6.GeneratorDeclaration";
    }

    static TParseTree GeneratorDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYield"), "GeneratorDeclarationYield")(p);
                memo[tuple(`GeneratorDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYield"), "GeneratorDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorDeclarationYield(GetName g)
    {
        return "ES6.GeneratorDeclarationYield";
    }

    static TParseTree GeneratorDeclarationDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationDefault")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorDeclarationDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationDefault"), "GeneratorDeclarationDefault")(p);
                memo[tuple(`GeneratorDeclarationDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorDeclarationDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifier, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParameters, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationDefault"), "GeneratorDeclarationDefault")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorDeclarationDefault(GetName g)
    {
        return "ES6.GeneratorDeclarationDefault";
    }

    static TParseTree GeneratorDeclarationYieldDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYieldDefault")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorDeclarationYieldDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYieldDefault"), "GeneratorDeclarationYieldDefault")(p);
                memo[tuple(`GeneratorDeclarationYieldDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorDeclarationYieldDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorDeclarationYieldDefault"), "GeneratorDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorDeclarationYieldDefault(GetName g)
    {
        return "ES6.GeneratorDeclarationYieldDefault";
    }

    static TParseTree GeneratorExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorExpression")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorExpression"), "GeneratorExpression")(p);
                memo[tuple(`GeneratorExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("function"), Spacing)), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("*"), Spacing)), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, BindingIdentifierYield, Spacing)), pegged.peg.wrapAround!(Spacing, Parentheses!(pegged.peg.wrapAround!(Spacing, FormalParametersYield, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, GeneratorBody, Spacing)), Spacing)), "ES6.GeneratorExpression"), "GeneratorExpression")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorExpression(GetName g)
    {
        return "ES6.GeneratorExpression";
    }

    static TParseTree GeneratorBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionBodyYield, Spacing), "ES6.GeneratorBody")(p);
        }
        else
        {
            if(auto m = tuple(`GeneratorBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionBodyYield, Spacing), "ES6.GeneratorBody"), "GeneratorBody")(p);
                memo[tuple(`GeneratorBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree GeneratorBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionBodyYield, Spacing), "ES6.GeneratorBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, FunctionBodyYield, Spacing), "ES6.GeneratorBody"), "GeneratorBody")(TParseTree("", false,[], s));
        }
    }
    static string GeneratorBody(GetName g)
    {
        return "ES6.GeneratorBody";
    }

    static TParseTree YieldExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionYield), pegged.peg.literal!("yield")), "ES6.YieldExpression")(p);
        }
        else
        {
            if(auto m = tuple(`YieldExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionYield), pegged.peg.literal!("yield")), "ES6.YieldExpression"), "YieldExpression")(p);
                memo[tuple(`YieldExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree YieldExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionYield), pegged.peg.literal!("yield")), "ES6.YieldExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionYield), pegged.peg.literal!("yield")), "ES6.YieldExpression"), "YieldExpression")(TParseTree("", false,[], s));
        }
    }
    static string YieldExpression(GetName g)
    {
        return "ES6.YieldExpression";
    }

    static TParseTree YieldExpressionIn(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionInYield), pegged.peg.literal!("yield")), "ES6.YieldExpressionIn")(p);
        }
        else
        {
            if(auto m = tuple(`YieldExpressionIn`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionInYield), pegged.peg.literal!("yield")), "ES6.YieldExpressionIn"), "YieldExpressionIn")(p);
                memo[tuple(`YieldExpressionIn`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree YieldExpressionIn(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionInYield), pegged.peg.literal!("yield")), "ES6.YieldExpressionIn")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.and!(pegged.peg.literal!("yield"), Spaces, pegged.peg.option!(pegged.peg.literal!("*")), AssignmentExpressionInYield), pegged.peg.literal!("yield")), "ES6.YieldExpressionIn"), "YieldExpressionIn")(TParseTree("", false,[], s));
        }
    }
    static string YieldExpressionIn(GetName g)
    {
        return "ES6.YieldExpressionIn";
    }

    static TParseTree ClassDeclaration(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifier, Spaces, ClassTail), "ES6.ClassDeclaration")(p);
        }
        else
        {
            if(auto m = tuple(`ClassDeclaration`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifier, Spaces, ClassTail), "ES6.ClassDeclaration"), "ClassDeclaration")(p);
                memo[tuple(`ClassDeclaration`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassDeclaration(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifier, Spaces, ClassTail), "ES6.ClassDeclaration")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifier, Spaces, ClassTail), "ES6.ClassDeclaration"), "ClassDeclaration")(TParseTree("", false,[], s));
        }
    }
    static string ClassDeclaration(GetName g)
    {
        return "ES6.ClassDeclaration";
    }

    static TParseTree ClassDeclarationYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifierYield, Spaces, ClassTailYield), "ES6.ClassDeclarationYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassDeclarationYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifierYield, Spaces, ClassTailYield), "ES6.ClassDeclarationYield"), "ClassDeclarationYield")(p);
                memo[tuple(`ClassDeclarationYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassDeclarationYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifierYield, Spaces, ClassTailYield), "ES6.ClassDeclarationYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, BindingIdentifierYield, Spaces, ClassTailYield), "ES6.ClassDeclarationYield"), "ClassDeclarationYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassDeclarationYield(GetName g)
    {
        return "ES6.ClassDeclarationYield";
    }

    static TParseTree ClassDeclarationDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassDeclarationDefault")(p);
        }
        else
        {
            if(auto m = tuple(`ClassDeclarationDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassDeclarationDefault"), "ClassDeclarationDefault")(p);
                memo[tuple(`ClassDeclarationDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassDeclarationDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassDeclarationDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassDeclarationDefault"), "ClassDeclarationDefault")(TParseTree("", false,[], s));
        }
    }
    static string ClassDeclarationDefault(GetName g)
    {
        return "ES6.ClassDeclarationDefault";
    }

    static TParseTree ClassDeclarationYieldDefault(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassDeclarationYieldDefault")(p);
        }
        else
        {
            if(auto m = tuple(`ClassDeclarationYieldDefault`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassDeclarationYieldDefault"), "ClassDeclarationYieldDefault")(p);
                memo[tuple(`ClassDeclarationYieldDefault`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassDeclarationYieldDefault(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassDeclarationYieldDefault"), "ClassDeclarationYieldDefault")(TParseTree("", false,[], s));
        }
    }
    static string ClassDeclarationYieldDefault(GetName g)
    {
        return "ES6.ClassDeclarationYieldDefault";
    }

    static TParseTree ClassExpression(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassExpression")(p);
        }
        else
        {
            if(auto m = tuple(`ClassExpression`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassExpression"), "ClassExpression")(p);
                memo[tuple(`ClassExpression`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassExpression(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassExpression")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifier), Spaces, ClassTail), "ES6.ClassExpression"), "ClassExpression")(TParseTree("", false,[], s));
        }
    }
    static string ClassExpression(GetName g)
    {
        return "ES6.ClassExpression";
    }

    static TParseTree ClassExpressionYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassExpressionYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassExpressionYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassExpressionYield"), "ClassExpressionYield")(p);
                memo[tuple(`ClassExpressionYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassExpressionYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassExpressionYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.literal!("class")), pegged.peg.negLookahead!(pegged.peg.or!(IdentifierStart, IdentifierPart)), Spaces, pegged.peg.option!(BindingIdentifierYield), Spaces, ClassTailYield), "ES6.ClassExpressionYield"), "ClassExpressionYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassExpressionYield(GetName g)
    {
        return "ES6.ClassExpressionYield";
    }

    static TParseTree ClassTail(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritage, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBody, Spacing))), Spacing)), "ES6.ClassTail")(p);
        }
        else
        {
            if(auto m = tuple(`ClassTail`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritage, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBody, Spacing))), Spacing)), "ES6.ClassTail"), "ClassTail")(p);
                memo[tuple(`ClassTail`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassTail(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritage, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBody, Spacing))), Spacing)), "ES6.ClassTail")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritage, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBody, Spacing))), Spacing)), "ES6.ClassTail"), "ClassTail")(TParseTree("", false,[], s));
        }
    }
    static string ClassTail(GetName g)
    {
        return "ES6.ClassTail";
    }

    static TParseTree ClassTailYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritageYield, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBodyYield, Spacing))), Spacing)), "ES6.ClassTailYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassTailYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritageYield, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBodyYield, Spacing))), Spacing)), "ES6.ClassTailYield"), "ClassTailYield")(p);
                memo[tuple(`ClassTailYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassTailYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritageYield, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBodyYield, Spacing))), Spacing)), "ES6.ClassTailYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassHeritageYield, Spacing)), pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.option!(pegged.peg.wrapAround!(Spacing, ClassBodyYield, Spacing))), Spacing)), "ES6.ClassTailYield"), "ClassTailYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassTailYield(GetName g)
    {
        return "ES6.ClassTailYield";
    }

    static TParseTree ClassHeritage(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing)), "ES6.ClassHeritage")(p);
        }
        else
        {
            if(auto m = tuple(`ClassHeritage`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing)), "ES6.ClassHeritage"), "ClassHeritage")(p);
                memo[tuple(`ClassHeritage`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassHeritage(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing)), "ES6.ClassHeritage")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpression, Spacing)), "ES6.ClassHeritage"), "ClassHeritage")(TParseTree("", false,[], s));
        }
    }
    static string ClassHeritage(GetName g)
    {
        return "ES6.ClassHeritage";
    }

    static TParseTree ClassHeritageYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing)), "ES6.ClassHeritageYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassHeritageYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing)), "ES6.ClassHeritageYield"), "ClassHeritageYield")(p);
                memo[tuple(`ClassHeritageYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassHeritageYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing)), "ES6.ClassHeritageYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("extends"), Spacing)), pegged.peg.wrapAround!(Spacing, LeftHandSideExpressionYield, Spacing)), "ES6.ClassHeritageYield"), "ClassHeritageYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassHeritageYield(GetName g)
    {
        return "ES6.ClassHeritageYield";
    }

    static TParseTree ClassBody(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementList, Spacing), "ES6.ClassBody")(p);
        }
        else
        {
            if(auto m = tuple(`ClassBody`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementList, Spacing), "ES6.ClassBody"), "ClassBody")(p);
                memo[tuple(`ClassBody`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassBody(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementList, Spacing), "ES6.ClassBody")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementList, Spacing), "ES6.ClassBody"), "ClassBody")(TParseTree("", false,[], s));
        }
    }
    static string ClassBody(GetName g)
    {
        return "ES6.ClassBody";
    }

    static TParseTree ClassBodyYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementListYield, Spacing), "ES6.ClassBodyYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassBodyYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementListYield, Spacing), "ES6.ClassBodyYield"), "ClassBodyYield")(p);
                memo[tuple(`ClassBodyYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassBodyYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementListYield, Spacing), "ES6.ClassBodyYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, ClassElementListYield, Spacing), "ES6.ClassBodyYield"), "ClassBodyYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassBodyYield(GetName g)
    {
        return "ES6.ClassBodyYield";
    }

    static TParseTree ClassElementList(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElement, Spacing)), "ES6.ClassElementList")(p);
        }
        else
        {
            if(auto m = tuple(`ClassElementList`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElement, Spacing)), "ES6.ClassElementList"), "ClassElementList")(p);
                memo[tuple(`ClassElementList`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassElementList(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElement, Spacing)), "ES6.ClassElementList")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElement, Spacing)), "ES6.ClassElementList"), "ClassElementList")(TParseTree("", false,[], s));
        }
    }
    static string ClassElementList(GetName g)
    {
        return "ES6.ClassElementList";
    }

    static TParseTree ClassElementListYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElementYield, Spacing)), "ES6.ClassElementListYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassElementListYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElementYield, Spacing)), "ES6.ClassElementListYield"), "ClassElementListYield")(p);
                memo[tuple(`ClassElementListYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassElementListYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElementYield, Spacing)), "ES6.ClassElementListYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.oneOrMore!(pegged.peg.wrapAround!(Spacing, ClassElementYield, Spacing)), "ES6.ClassElementListYield"), "ClassElementListYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassElementListYield(GetName g)
    {
        return "ES6.ClassElementListYield";
    }

    static TParseTree ClassElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), "ES6.ClassElement")(p);
        }
        else
        {
            if(auto m = tuple(`ClassElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), "ES6.ClassElement"), "ClassElement")(p);
                memo[tuple(`ClassElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), "ES6.ClassElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinition, Spacing)), "ES6.ClassElement"), "ClassElement")(TParseTree("", false,[], s));
        }
    }
    static string ClassElement(GetName g)
    {
        return "ES6.ClassElement";
    }

    static TParseTree ClassElementYield(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), "ES6.ClassElementYield")(p);
        }
        else
        {
            if(auto m = tuple(`ClassElementYield`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), "ES6.ClassElementYield"), "ClassElementYield")(p);
                memo[tuple(`ClassElementYield`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree ClassElementYield(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), "ES6.ClassElementYield")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("static"), Spacing), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), Spacing), pegged.peg.discard!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(";"), Spacing)), pegged.peg.wrapAround!(Spacing, MethodDefinitionYield, Spacing)), "ES6.ClassElementYield"), "ClassElementYield")(TParseTree("", false,[], s));
        }
    }
    static string ClassElementYield(GetName g)
    {
        return "ES6.ClassElementYield";
    }

    static TParseTree JSXElement(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, JSXAttributeSet, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, JSXContent, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("</"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing)), Spacing)), Spacing)), "ES6.JSXElement")(p);
        }
        else
        {
            if(auto m = tuple(`JSXElement`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, JSXAttributeSet, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, JSXContent, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("</"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing)), Spacing)), Spacing)), "ES6.JSXElement"), "JSXElement")(p);
                memo[tuple(`JSXElement`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXElement(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, JSXAttributeSet, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, JSXContent, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("</"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing)), Spacing)), Spacing)), "ES6.JSXElement")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("<"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, JSXAttributeSet, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("/>"), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing), pegged.peg.wrapAround!(Spacing, JSXContent, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("</"), Spacing), pegged.peg.wrapAround!(Spacing, JSXTag, Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.literal!(">"), Spacing)), Spacing)), Spacing)), "ES6.JSXElement"), "JSXElement")(TParseTree("", false,[], s));
        }
    }
    static string JSXElement(GetName g)
    {
        return "ES6.JSXElement";
    }

    static TParseTree JSXAttributeSet(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, JSXAttribute, Spacing)), "ES6.JSXAttributeSet")(p);
        }
        else
        {
            if(auto m = tuple(`JSXAttributeSet`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, JSXAttribute, Spacing)), "ES6.JSXAttributeSet"), "JSXAttributeSet")(p);
                memo[tuple(`JSXAttributeSet`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXAttributeSet(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, JSXAttribute, Spacing)), "ES6.JSXAttributeSet")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, JSXAttribute, Spacing)), "ES6.JSXAttributeSet"), "JSXAttributeSet")(TParseTree("", false,[], s));
        }
    }
    static string JSXAttributeSet(GetName g)
    {
        return "ES6.JSXAttributeSet";
    }

    static TParseTree JSXAttribute(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, JSXKey, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing), pegged.peg.wrapAround!(Spacing, JSXValue, Spacing)), Spacing))), Spacing)), "ES6.JSXAttribute")(p);
        }
        else
        {
            if(auto m = tuple(`JSXAttribute`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, JSXKey, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing), pegged.peg.wrapAround!(Spacing, JSXValue, Spacing)), Spacing))), Spacing)), "ES6.JSXAttribute"), "JSXAttribute")(p);
                memo[tuple(`JSXAttribute`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXAttribute(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, JSXKey, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing), pegged.peg.wrapAround!(Spacing, JSXValue, Spacing)), Spacing))), Spacing)), "ES6.JSXAttribute")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, SpreadElement, Spacing)), Spacing), pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, JSXKey, Spacing), pegged.peg.option!(pegged.peg.wrapAround!(Spacing, pegged.peg.and!(pegged.peg.wrapAround!(Spacing, pegged.peg.literal!("="), Spacing), pegged.peg.wrapAround!(Spacing, JSXValue, Spacing)), Spacing))), Spacing)), "ES6.JSXAttribute"), "JSXAttribute")(TParseTree("", false,[], s));
        }
    }
    static string JSXAttribute(GetName g)
    {
        return "ES6.JSXAttribute";
    }

    static TParseTree JSXKey(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("=", "/>", ">")), pegged.peg.any))), "ES6.JSXKey")(p);
        }
        else
        {
            if(auto m = tuple(`JSXKey`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("=", "/>", ">")), pegged.peg.any))), "ES6.JSXKey"), "JSXKey")(p);
                memo[tuple(`JSXKey`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXKey(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("=", "/>", ">")), pegged.peg.any))), "ES6.JSXKey")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.oneOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.keywords!("=", "/>", ">")), pegged.peg.any))), "ES6.JSXKey"), "JSXKey")(TParseTree("", false,[], s));
        }
    }
    static string JSXKey(GetName g)
    {
        return "ES6.JSXKey";
    }

    static TParseTree JSXInlineJS(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), "ES6.JSXInlineJS")(p);
        }
        else
        {
            if(auto m = tuple(`JSXInlineJS`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), "ES6.JSXInlineJS"), "JSXInlineJS")(p);
                memo[tuple(`JSXInlineJS`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXInlineJS(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), "ES6.JSXInlineJS")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, ArrowFunction, Spacing), pegged.peg.wrapAround!(Spacing, ConditionalExpression, Spacing)), "ES6.JSXInlineJS"), "JSXInlineJS")(TParseTree("", false,[], s));
        }
    }
    static string JSXInlineJS(GetName g)
    {
        return "ES6.JSXInlineJS";
    }

    static TParseTree JSXValue(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing)), "ES6.JSXValue")(p);
        }
        else
        {
            if(auto m = tuple(`JSXValue`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing)), "ES6.JSXValue"), "JSXValue")(p);
                memo[tuple(`JSXValue`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXValue(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing)), "ES6.JSXValue")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.or!(pegged.peg.wrapAround!(Spacing, StringLiteral, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing)), "ES6.JSXValue"), "JSXValue")(TParseTree("", false,[], s));
        }
    }
    static string JSXValue(GetName g)
    {
        return "ES6.JSXValue";
    }

    static TParseTree JSXCodeBlock(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing)), Spacing), "ES6.JSXCodeBlock")(p);
        }
        else
        {
            if(auto m = tuple(`JSXCodeBlock`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing)), Spacing), "ES6.JSXCodeBlock"), "JSXCodeBlock")(p);
                memo[tuple(`JSXCodeBlock`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXCodeBlock(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing)), Spacing), "ES6.JSXCodeBlock")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing)), Spacing), "ES6.JSXCodeBlock"), "JSXCodeBlock")(TParseTree("", false,[], s));
        }
    }
    static string JSXCodeBlock(GetName g)
    {
        return "ES6.JSXCodeBlock";
    }

    static TParseTree JSXJavaScriptValue(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing)), pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing))), Spacing), "ES6.JSXJavaScriptValue")(p);
        }
        else
        {
            if(auto m = tuple(`JSXJavaScriptValue`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing)), pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing))), Spacing), "ES6.JSXJavaScriptValue"), "JSXJavaScriptValue")(p);
                memo[tuple(`JSXJavaScriptValue`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXJavaScriptValue(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing)), pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing))), Spacing), "ES6.JSXJavaScriptValue")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.wrapAround!(Spacing, CurlyBrackets!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing)), pegged.peg.wrapAround!(Spacing, JSXInlineJS, Spacing))), Spacing), "ES6.JSXJavaScriptValue"), "JSXJavaScriptValue")(TParseTree("", false,[], s));
        }
    }
    static string JSXJavaScriptValue(GetName g)
    {
        return "ES6.JSXJavaScriptValue";
    }

    static TParseTree JSXTag(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z')), pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z'), pegged.peg.charRange!('0', '9'))))), "ES6.JSXTag")(p);
        }
        else
        {
            if(auto m = tuple(`JSXTag`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z')), pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z'), pegged.peg.charRange!('0', '9'))))), "ES6.JSXTag"), "JSXTag")(p);
                memo[tuple(`JSXTag`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXTag(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z')), pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z'), pegged.peg.charRange!('0', '9'))))), "ES6.JSXTag")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.and!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z')), pegged.peg.zeroOrMore!(pegged.peg.or!(pegged.peg.charRange!('a', 'z'), pegged.peg.charRange!('A', 'Z'), pegged.peg.charRange!('0', '9'))))), "ES6.JSXTag"), "JSXTag")(TParseTree("", false,[], s));
        }
    }
    static string JSXTag(GetName g)
    {
        return "ES6.JSXTag";
    }

    static TParseTree JSXContent(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing), pegged.peg.wrapAround!(Spacing, JSXContentText, Spacing)), Spacing)), "ES6.JSXContent")(p);
        }
        else
        {
            if(auto m = tuple(`JSXContent`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing), pegged.peg.wrapAround!(Spacing, JSXContentText, Spacing)), Spacing)), "ES6.JSXContent"), "JSXContent")(p);
                memo[tuple(`JSXContent`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXContent(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing), pegged.peg.wrapAround!(Spacing, JSXContentText, Spacing)), Spacing)), "ES6.JSXContent")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.zeroOrMore!(pegged.peg.wrapAround!(Spacing, pegged.peg.or!(pegged.peg.wrapAround!(Spacing, JSXElement, Spacing), pegged.peg.wrapAround!(Spacing, JSXCodeBlock, Spacing), pegged.peg.wrapAround!(Spacing, JSXContentText, Spacing)), Spacing)), "ES6.JSXContent"), "JSXContent")(TParseTree("", false,[], s));
        }
    }
    static string JSXContent(GetName g)
    {
        return "ES6.JSXContent";
    }

    static TParseTree JSXContentText(TParseTree p)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("</")), SourceCharacter))), "ES6.JSXContentText")(p);
        }
        else
        {
            if(auto m = tuple(`JSXContentText`,p.end) in memo)
                return *m;
            else
            {
                TParseTree result = hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("</")), SourceCharacter))), "ES6.JSXContentText"), "JSXContentText")(p);
                memo[tuple(`JSXContentText`,p.end)] = result;
                return result;
            }
        }
    }

    static TParseTree JSXContentText(string s)
    {
        if(__ctfe)
        {
            return         pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("</")), SourceCharacter))), "ES6.JSXContentText")(TParseTree("", false,[], s));
        }
        else
        {
            memo = null;
            return hooked!(pegged.peg.defined!(pegged.peg.fuse!(pegged.peg.zeroOrMore!(pegged.peg.and!(pegged.peg.negLookahead!(pegged.peg.literal!("</")), SourceCharacter))), "ES6.JSXContentText"), "JSXContentText")(TParseTree("", false,[], s));
        }
    }
    static string JSXContentText(GetName g)
    {
        return "ES6.JSXContentText";
    }

    static TParseTree opCall(TParseTree p)
    {
        TParseTree result = decimateTree(Module(p));
        result.children = [result];
        result.name = "ES6";
        return result;
    }

    static TParseTree opCall(string input)
    {
        if(__ctfe)
        {
            return ES6(TParseTree(``, false, [], input, 0, 0));
        }
        else
        {
            memo = null;
            return ES6(TParseTree(``, false, [], input, 0, 0));
        }
    }
    static string opCall(GetName g)
    {
        return "ES6";
    }

    }
}

alias GenericES6!(ParseTree).ES6 ES6;