parseUnit(Future)
  skipErrorTokens(Future)
  listener: beginCompilationUnit(Future)
  syntheticPreviousToken(Future)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(Future)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(Future)
      parseTopLevelMethod(, null, null, , Instance of 'SimpleTypeWith1Argument', null, returnsFuture, false)
        listener: beginTopLevelMethod(, null, null)
        listener: handleIdentifier(Future, typeReference)
        listener: beginTypeArguments(<)
        listener: handleIdentifier(bool, typeReference)
        listener: handleNoTypeArguments(>)
        listener: handleType(bool, null)
        listener: endTypeArguments(1, <, >)
        listener: handleType(Future, null)
        ensureIdentifierPotentiallyRecovered(>, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(returnsFuture, topLevelFunctionDeclaration)
        parseMethodTypeVar(returnsFuture)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(returnsFuture, returnsFuture, false, MemberKind.TopLevelMethod)
          parseFormalParameters(returnsFuture, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          parseExpressionFunctionBody(=>, false)
            parseExpression(=>)
              parsePrecedenceExpression(=>, 1, true)
                parseUnaryExpression(=>, true)
                  parsePrimary(=>, expression)
                    parseNewExpression(=>)
                      isNextIdentifier(new)
                      listener: beginNewExpression(new)
                      parseConstructorReference(new, ConstructorReferenceContext.New, null)
                        ensureIdentifier(new, constructorReference)
                          listener: handleIdentifier(Future, constructorReference)
                        listener: beginConstructorReference(Future)
                        parseQualifiedRestOpt(Future, constructorReferenceContinuation)
                          parseQualifiedRest(Future, constructorReferenceContinuation)
                            ensureIdentifier(., constructorReferenceContinuation)
                              listener: handleIdentifier(value, constructorReferenceContinuation)
                            listener: handleQualified(.)
                        listener: handleNoTypeArguments(()
                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                        listener: endConstructorReference(Future, null, (, ConstructorReferenceContext.New)
                      parseConstructorInvocationArguments(value)
                        parseArgumentsRest(()
                          listener: beginArguments(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseLiteralBool(()
                                    listener: handleLiteralBool(true)
                          listener: endArguments(1, (, ))
                      listener: endNewExpression(new)
            ensureSemicolon())
            listener: handleExpressionFunctionBody(=>, ;)
            inGenerator()
        listener: endTopLevelMethod(Future, null, ;)
  listener: endTopLevelDeclaration(void)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(void)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(;)
      listener: beginTopLevelMember(void)
      parseTopLevelMethod(;, null, null, ;, Instance of 'VoidType', null, foo, false)
        listener: beginTopLevelMethod(;, null, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
        parseMethodTypeVar(foo)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
          parseFormalParameters(foo, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, await)
          parseStatement({)
            parseStatementX({)
              inPlainSync()
              looksLikeAwaitExpression({, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement({)
                parseExpression({)
                  parsePrecedenceExpression({, 1, true)
                    parseUnaryExpression({, true)
                      inPlainSync()
                      looksLikeAwaitExpression({, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression({, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                looksLikeFunctionBody(;)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(returnsFuture, expression)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(returnsFuture)
                                    parseArguments(returnsFuture)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                  listener: handleSend(returnsFuture, ;)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                ensureSemicolon())
                listener: handleExpressionStatement(;)
          notEofOrValue(}, if)
          parseStatement(;)
            parseStatementX(;)
              parseIfStatement(;)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          inPlainSync()
                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                          parseAwaitExpression((, true)
                            listener: beginAwaitExpression(await)
                            parsePrecedenceExpression(await, 16, true)
                              parseUnaryExpression(await, true)
                                parsePrimary(await, expression)
                                  parseSendOrFunctionLiteral(await, expression)
                                    looksLikeFunctionBody())
                                    parseSend(await, expression)
                                      isNextIdentifier(await)
                                      ensureIdentifier(await, expression)
                                        listener: handleIdentifier(returnsFuture, expression)
                                      listener: handleNoTypeArguments(()
                                      parseArgumentsOpt(returnsFuture)
                                        parseArguments(returnsFuture)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            listener: endArguments(0, (, ))
                                      listener: handleSend(returnsFuture, ))
                            inAsync()
                            reportRecoverableError(await, AwaitNotAsync)
                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                    ensureCloseParen(), ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement({)
                parseStatement())
                  parseStatementX())
                    parseBlock(), BlockKind(statement))
                      ensureBlock(), null, null)
                      listener: beginBlock({, BlockKind(statement))
                      notEofOrValue(}, })
                      listener: endBlock(0, {, }, BlockKind(statement))
                listener: endThenStatement(})
                listener: beginElseStatement(else)
                parseStatement(else)
                  parseStatementX(else)
                    parseIfStatement(else)
                      listener: beginIfStatement(if)
                      ensureParenthesizedCondition(if)
                        parseExpressionInParenthesisRest(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrecedenceExpression(!, 16, true)
                                  parseUnaryExpression(!, true)
                                    inPlainSync()
                                    looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                      looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                    parseAwaitExpression(!, true)
                                      listener: beginAwaitExpression(await)
                                      parsePrecedenceExpression(await, 16, true)
                                        parseUnaryExpression(await, true)
                                          parsePrimary(await, expression)
                                            parseSendOrFunctionLiteral(await, expression)
                                              looksLikeFunctionBody())
                                              parseSend(await, expression)
                                                isNextIdentifier(await)
                                                ensureIdentifier(await, expression)
                                                  listener: handleIdentifier(returnsFuture, expression)
                                                listener: handleNoTypeArguments(()
                                                parseArgumentsOpt(returnsFuture)
                                                  parseArguments(returnsFuture)
                                                    parseArgumentsRest(()
                                                      listener: beginArguments(()
                                                      listener: endArguments(0, (, ))
                                                listener: handleSend(returnsFuture, ))
                                      inAsync()
                                      reportRecoverableError(await, AwaitNotAsync)
                                        listener: handleRecoverableError(AwaitNotAsync, await, await)
                                      listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                listener: handleUnaryPrefixExpression(!)
                          ensureCloseParen(), ()
                        listener: handleParenthesizedCondition(()
                      listener: beginThenStatement({)
                      parseStatement())
                        parseStatementX())
                          parseBlock(), BlockKind(statement))
                            ensureBlock(), null, null)
                            listener: beginBlock({, BlockKind(statement))
                            notEofOrValue(}, })
                            listener: endBlock(0, {, }, BlockKind(statement))
                      listener: endThenStatement(})
                      listener: endIfStatement(if, null)
                listener: endElseStatement(else)
                listener: endIfStatement(if, else)
          notEofOrValue(}, print)
          parseStatement(})
            parseStatementX(})
              parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(})
                  parseExpression(})
                    parsePrecedenceExpression(}, 1, true)
                      parseUnaryExpression(}, true)
                        parsePrimary(}, expression)
                          parseSendOrFunctionLiteral(}, expression)
                            looksLikeFunctionBody(;)
                            parseSend(}, expression)
                              isNextIdentifier(})
                              ensureIdentifier(}, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody())
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, ))
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, xor)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(xor)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(xor, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(xor)
                                parseArguments(xor)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody(,)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, ,)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                    parseExpression(,)
                                      parsePrecedenceExpression(,, 1, true)
                                        parseUnaryExpression(,, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression(,, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody(,)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, ,)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                    parseExpression(,)
                                      parsePrecedenceExpression(,, 1, true)
                                        parseUnaryExpression(,, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression(,, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody())
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, ))
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                    listener: endArguments(3, (, ))
                              listener: handleSend(xor, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                looksLikeFunctionBody(^)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(returnsFuture, expression)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(returnsFuture)
                                    parseArguments(returnsFuture)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                  listener: handleSend(returnsFuture, ^)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                    listener: beginBinaryExpression(^)
                    parsePrecedenceExpression(^, 11, true)
                      parseUnaryExpression(^, true)
                        inPlainSync()
                        looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(^, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  looksLikeFunctionBody(;)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(returnsFuture, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(returnsFuture)
                                      parseArguments(returnsFuture)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          listener: endArguments(0, (, ))
                                    listener: handleSend(returnsFuture, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(^)
                ensureSemicolon())
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody(^)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, ^)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                        listener: beginBinaryExpression(^)
                                        parsePrecedenceExpression(^, 11, true)
                                          parseUnaryExpression(^, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(^, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      looksLikeFunctionBody())
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(returnsFuture, expression)
                                                        listener: handleNoTypeArguments(()
                                                        parseArgumentsOpt(returnsFuture)
                                                          parseArguments(returnsFuture)
                                                            parseArgumentsRest(()
                                                              listener: beginArguments(()
                                                              listener: endArguments(0, (, ))
                                                        listener: handleSend(returnsFuture, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(^)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                looksLikeFunctionBody(+)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(returnsFuture, expression)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(returnsFuture)
                                    parseArguments(returnsFuture)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                  listener: handleSend(returnsFuture, +)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        inPlainSync()
                        looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(+, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  looksLikeFunctionBody(;)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(returnsFuture, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(returnsFuture)
                                      parseArguments(returnsFuture)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          listener: endArguments(0, (, ))
                                    listener: handleSend(returnsFuture, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(+)
                ensureSemicolon())
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody(+)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, +)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                                        listener: beginBinaryExpression(+)
                                        parsePrecedenceExpression(+, 14, true)
                                          parseUnaryExpression(+, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(+, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      looksLikeFunctionBody())
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(returnsFuture, expression)
                                                        listener: handleNoTypeArguments(()
                                                        parseArgumentsOpt(returnsFuture)
                                                          parseArguments(returnsFuture)
                                                            parseArgumentsRest(()
                                                              listener: beginArguments(()
                                                              listener: endArguments(0, (, ))
                                                        listener: handleSend(returnsFuture, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(+)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                looksLikeFunctionBody(-)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(returnsFuture, expression)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(returnsFuture)
                                    parseArguments(returnsFuture)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                  listener: handleSend(returnsFuture, -)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                    listener: beginBinaryExpression(-)
                    parsePrecedenceExpression(-, 14, true)
                      parseUnaryExpression(-, true)
                        inPlainSync()
                        looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(-, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  looksLikeFunctionBody(;)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(returnsFuture, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(returnsFuture)
                                      parseArguments(returnsFuture)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          listener: endArguments(0, (, ))
                                    listener: handleSend(returnsFuture, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(-)
                ensureSemicolon())
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    looksLikeFunctionBody(-)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(returnsFuture, expression)
                                                      listener: handleNoTypeArguments(()
                                                      parseArgumentsOpt(returnsFuture)
                                                        parseArguments(returnsFuture)
                                                          parseArgumentsRest(()
                                                            listener: beginArguments(()
                                                            listener: endArguments(0, (, ))
                                                      listener: handleSend(returnsFuture, -)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(-, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      looksLikeFunctionBody())
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(returnsFuture, expression)
                                                        listener: handleNoTypeArguments(()
                                                        parseArgumentsOpt(returnsFuture)
                                                          parseArguments(returnsFuture)
                                                            parseArgumentsRest(()
                                                              listener: beginArguments(()
                                                              listener: endArguments(0, (, ))
                                                        listener: handleSend(returnsFuture, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(-)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, !)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(!)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrecedenceExpression(!, 16, true)
                            parseUnaryExpression(!, true)
                              inPlainSync()
                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                              parseAwaitExpression(!, true)
                                listener: beginAwaitExpression(await)
                                parsePrecedenceExpression(await, 16, true)
                                  parseUnaryExpression(await, true)
                                    parsePrimary(await, expression)
                                      parseSendOrFunctionLiteral(await, expression)
                                        looksLikeFunctionBody(^)
                                        parseSend(await, expression)
                                          isNextIdentifier(await)
                                          ensureIdentifier(await, expression)
                                            listener: handleIdentifier(returnsFuture, expression)
                                          listener: handleNoTypeArguments(()
                                          parseArgumentsOpt(returnsFuture)
                                            parseArguments(returnsFuture)
                                              parseArgumentsRest(()
                                                listener: beginArguments(()
                                                listener: endArguments(0, (, ))
                                          listener: handleSend(returnsFuture, ^)
                                inAsync()
                                reportRecoverableError(await, AwaitNotAsync)
                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                          listener: handleUnaryPrefixExpression(!)
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrecedenceExpression(!, 16, true)
                              parseUnaryExpression(!, true)
                                inPlainSync()
                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                parseAwaitExpression(!, true)
                                  listener: beginAwaitExpression(await)
                                  parsePrecedenceExpression(await, 16, true)
                                    parseUnaryExpression(await, true)
                                      parsePrimary(await, expression)
                                        parseSendOrFunctionLiteral(await, expression)
                                          looksLikeFunctionBody(;)
                                          parseSend(await, expression)
                                            isNextIdentifier(await)
                                            ensureIdentifier(await, expression)
                                              listener: handleIdentifier(returnsFuture, expression)
                                            listener: handleNoTypeArguments(()
                                            parseArgumentsOpt(returnsFuture)
                                              parseArguments(returnsFuture)
                                                parseArgumentsRest(()
                                                  listener: beginArguments(()
                                                  listener: endArguments(0, (, ))
                                            listener: handleSend(returnsFuture, ;)
                                  inAsync()
                                  reportRecoverableError(await, AwaitNotAsync)
                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
                                  listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                            listener: handleUnaryPrefixExpression(!)
                        listener: endBinaryExpression(^)
                    ensureSemicolon())
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrecedenceExpression(!, 16, true)
                                            parseUnaryExpression(!, true)
                                              inPlainSync()
                                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                              parseAwaitExpression(!, true)
                                                listener: beginAwaitExpression(await)
                                                parsePrecedenceExpression(await, 16, true)
                                                  parseUnaryExpression(await, true)
                                                    parsePrimary(await, expression)
                                                      parseSendOrFunctionLiteral(await, expression)
                                                        looksLikeFunctionBody(^)
                                                        parseSend(await, expression)
                                                          isNextIdentifier(await)
                                                          ensureIdentifier(await, expression)
                                                            listener: handleIdentifier(returnsFuture, expression)
                                                          listener: handleNoTypeArguments(()
                                                          parseArgumentsOpt(returnsFuture)
                                                            parseArguments(returnsFuture)
                                                              parseArgumentsRest(()
                                                                listener: beginArguments(()
                                                                listener: endArguments(0, (, ))
                                                          listener: handleSend(returnsFuture, ^)
                                                inAsync()
                                                reportRecoverableError(await, AwaitNotAsync)
                                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
                                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                          listener: handleUnaryPrefixExpression(!)
                                        listener: beginBinaryExpression(^)
                                        parsePrecedenceExpression(^, 11, true)
                                          parseUnaryExpression(^, true)
                                            parsePrecedenceExpression(!, 16, true)
                                              parseUnaryExpression(!, true)
                                                inPlainSync()
                                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                                parseAwaitExpression(!, true)
                                                  listener: beginAwaitExpression(await)
                                                  parsePrecedenceExpression(await, 16, true)
                                                    parseUnaryExpression(await, true)
                                                      parsePrimary(await, expression)
                                                        parseSendOrFunctionLiteral(await, expression)
                                                          looksLikeFunctionBody())
                                                          parseSend(await, expression)
                                                            isNextIdentifier(await)
                                                            ensureIdentifier(await, expression)
                                                              listener: handleIdentifier(returnsFuture, expression)
                                                            listener: handleNoTypeArguments(()
                                                            parseArgumentsOpt(returnsFuture)
                                                              parseArguments(returnsFuture)
                                                                parseArgumentsRest(()
                                                                  listener: beginArguments(()
                                                                  listener: endArguments(0, (, ))
                                                            listener: handleSend(returnsFuture, ))
                                                  inAsync()
                                                  reportRecoverableError(await, AwaitNotAsync)
                                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
                                                  listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                            listener: handleUnaryPrefixExpression(!)
                                        listener: endBinaryExpression(^)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, var)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false)
                looksLikeLocalFunction(f)
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
                listener: handleNoType(var)
                listener: beginVariablesDeclaration(f, null, var)
                parseVariablesDeclarationRest(var, true)
                  parseOptionallyInitializedIdentifier(var)
                    ensureIdentifier(var, localVariableDeclaration)
                      listener: handleIdentifier(f, localVariableDeclaration)
                    listener: beginInitializedIdentifier(f)
                    parseVariableInitializerOpt(f)
                      listener: beginVariableInitializer(=)
                      parseExpression(=)
                        parsePrecedenceExpression(=, 1, true)
                          parseUnaryExpression(=, true)
                            parsePrimary(=, expression)
                              parseSendOrFunctionLiteral(=, expression)
                                looksLikeFunctionBody(;)
                                parseSend(=, expression)
                                  isNextIdentifier(=)
                                  ensureIdentifier(=, expression)
                                    listener: handleIdentifier(returnsFuture, expression)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(returnsFuture)
                                    parseArguments(returnsFuture)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                  listener: handleSend(returnsFuture, ;)
                      listener: endVariableInitializer(=)
                    listener: endInitializedIdentifier(f)
                  ensureSemicolon())
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(f)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(f)
                  listener: handleType(await, null)
                  listener: beginVariablesDeclaration(f, null, null)
                  parseVariablesDeclarationRest(await, true)
                    parseOptionallyInitializedIdentifier(await)
                      ensureIdentifier(await, localVariableDeclaration)
                        listener: handleIdentifier(f, localVariableDeclaration)
                      listener: beginInitializedIdentifier(f)
                      parseVariableInitializerOpt(f)
                        listener: handleNoVariableInitializer(f)
                      listener: endInitializedIdentifier(f)
                    ensureSemicolon(f)
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, if)
          parseStatement(;)
            parseStatementX(;)
              parseIfStatement(;)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          inPlainSync()
                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                          parseAwaitExpression((, true)
                            listener: beginAwaitExpression(await)
                            parsePrecedenceExpression(await, 16, true)
                              parseUnaryExpression(await, true)
                                parsePrimary(await, expression)
                                  parseSendOrFunctionLiteral(await, expression)
                                    parseSend(await, expression)
                                      isNextIdentifier(await)
                                      ensureIdentifier(await, expression)
                                        listener: handleIdentifier(f, expression)
                                      listener: handleNoTypeArguments())
                                      parseArgumentsOpt(f)
                                        listener: handleNoArguments())
                                      listener: handleSend(f, ))
                            inAsync()
                            reportRecoverableError(await, AwaitNotAsync)
                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                    ensureCloseParen(f, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement({)
                parseStatement())
                  parseStatementX())
                    parseBlock(), BlockKind(statement))
                      ensureBlock(), null, null)
                      listener: beginBlock({, BlockKind(statement))
                      notEofOrValue(}, })
                      listener: endBlock(0, {, }, BlockKind(statement))
                listener: endThenStatement(})
                listener: beginElseStatement(else)
                parseStatement(else)
                  parseStatementX(else)
                    parseIfStatement(else)
                      listener: beginIfStatement(if)
                      ensureParenthesizedCondition(if)
                        parseExpressionInParenthesisRest(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrecedenceExpression(!, 16, true)
                                  parseUnaryExpression(!, true)
                                    inPlainSync()
                                    looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                      looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                    parseAwaitExpression(!, true)
                                      listener: beginAwaitExpression(await)
                                      parsePrecedenceExpression(await, 16, true)
                                        parseUnaryExpression(await, true)
                                          parsePrimary(await, expression)
                                            parseSendOrFunctionLiteral(await, expression)
                                              parseSend(await, expression)
                                                isNextIdentifier(await)
                                                ensureIdentifier(await, expression)
                                                  listener: handleIdentifier(f, expression)
                                                listener: handleNoTypeArguments())
                                                parseArgumentsOpt(f)
                                                  listener: handleNoArguments())
                                                listener: handleSend(f, ))
                                      inAsync()
                                      reportRecoverableError(await, AwaitNotAsync)
                                        listener: handleRecoverableError(AwaitNotAsync, await, await)
                                      listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                listener: handleUnaryPrefixExpression(!)
                          ensureCloseParen(f, ()
                        listener: handleParenthesizedCondition(()
                      listener: beginThenStatement({)
                      parseStatement())
                        parseStatementX())
                          parseBlock(), BlockKind(statement))
                            ensureBlock(), null, null)
                            listener: beginBlock({, BlockKind(statement))
                            notEofOrValue(}, })
                            listener: endBlock(0, {, }, BlockKind(statement))
                      listener: endThenStatement(})
                      listener: endIfStatement(if, null)
                listener: endElseStatement(else)
                listener: endIfStatement(if, else)
          notEofOrValue(}, print)
          parseStatement(})
            parseStatementX(})
              parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(})
                  parseExpression(})
                    parsePrecedenceExpression(}, 1, true)
                      parseUnaryExpression(}, true)
                        parsePrimary(}, expression)
                          parseSendOrFunctionLiteral(}, expression)
                            looksLikeFunctionBody(;)
                            parseSend(}, expression)
                              isNextIdentifier(})
                              ensureIdentifier(}, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments())
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments())
                                                      listener: handleSend(f, ))
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, xor)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(xor)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(xor, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(xor)
                                parseArguments(xor)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments(,)
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments(,)
                                                      listener: handleSend(f, ,)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                    parseExpression(,)
                                      parsePrecedenceExpression(,, 1, true)
                                        parseUnaryExpression(,, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression(,, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments(,)
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments(,)
                                                      listener: handleSend(f, ,)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                    parseExpression(,)
                                      parsePrecedenceExpression(,, 1, true)
                                        parseUnaryExpression(,, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression(,, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments())
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments())
                                                      listener: handleSend(f, ))
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                    listener: endArguments(3, (, ))
                              listener: handleSend(xor, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(f, expression)
                                  listener: handleNoTypeArguments(^)
                                  parseArgumentsOpt(f)
                                    listener: handleNoArguments(^)
                                  listener: handleSend(f, ^)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                    listener: beginBinaryExpression(^)
                    parsePrecedenceExpression(^, 11, true)
                      parseUnaryExpression(^, true)
                        inPlainSync()
                        looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(^, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(f, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(f)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(f, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(^)
                ensureSemicolon(f)
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments(^)
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments(^)
                                                      listener: handleSend(f, ^)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                        listener: beginBinaryExpression(^)
                                        parsePrecedenceExpression(^, 11, true)
                                          parseUnaryExpression(^, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(^, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(f, expression)
                                                        listener: handleNoTypeArguments())
                                                        parseArgumentsOpt(f)
                                                          listener: handleNoArguments())
                                                        listener: handleSend(f, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(^)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(f, expression)
                                  listener: handleNoTypeArguments(+)
                                  parseArgumentsOpt(f)
                                    listener: handleNoArguments(+)
                                  listener: handleSend(f, +)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        inPlainSync()
                        looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(+, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(f, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(f)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(f, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(+)
                ensureSemicolon(f)
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments(+)
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments(+)
                                                      listener: handleSend(f, +)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                                        listener: beginBinaryExpression(+)
                                        parsePrecedenceExpression(+, 14, true)
                                          parseUnaryExpression(+, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(+, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(f, expression)
                                                        listener: handleNoTypeArguments())
                                                        parseArgumentsOpt(f)
                                                          listener: handleNoArguments())
                                                        listener: handleSend(f, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(+)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatement(;)
                parseExpression(;)
                  parsePrecedenceExpression(;, 1, true)
                    parseUnaryExpression(;, true)
                      inPlainSync()
                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                      parseAwaitExpression(;, true)
                        listener: beginAwaitExpression(await)
                        parsePrecedenceExpression(await, 16, true)
                          parseUnaryExpression(await, true)
                            parsePrimary(await, expression)
                              parseSendOrFunctionLiteral(await, expression)
                                parseSend(await, expression)
                                  isNextIdentifier(await)
                                  ensureIdentifier(await, expression)
                                    listener: handleIdentifier(f, expression)
                                  listener: handleNoTypeArguments(-)
                                  parseArgumentsOpt(f)
                                    listener: handleNoArguments(-)
                                  listener: handleSend(f, -)
                        inAsync()
                        reportRecoverableError(await, AwaitNotAsync)
                          listener: handleRecoverableError(AwaitNotAsync, await, await)
                        listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                    listener: beginBinaryExpression(-)
                    parsePrecedenceExpression(-, 14, true)
                      parseUnaryExpression(-, true)
                        inPlainSync()
                        looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                        parseAwaitExpression(-, true)
                          listener: beginAwaitExpression(await)
                          parsePrecedenceExpression(await, 16, true)
                            parseUnaryExpression(await, true)
                              parsePrimary(await, expression)
                                parseSendOrFunctionLiteral(await, expression)
                                  parseSend(await, expression)
                                    isNextIdentifier(await)
                                    ensureIdentifier(await, expression)
                                      listener: handleIdentifier(f, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(f)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(f, ;)
                          inAsync()
                          reportRecoverableError(await, AwaitNotAsync)
                            listener: handleRecoverableError(AwaitNotAsync, await, await)
                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                    listener: endBinaryExpression(-)
                ensureSemicolon(f)
                listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          inPlainSync()
                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                          parseAwaitExpression((, true)
                                            listener: beginAwaitExpression(await)
                                            parsePrecedenceExpression(await, 16, true)
                                              parseUnaryExpression(await, true)
                                                parsePrimary(await, expression)
                                                  parseSendOrFunctionLiteral(await, expression)
                                                    parseSend(await, expression)
                                                      isNextIdentifier(await)
                                                      ensureIdentifier(await, expression)
                                                        listener: handleIdentifier(f, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(f)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(f, -)
                                            inAsync()
                                            reportRecoverableError(await, AwaitNotAsync)
                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
                                            listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            inPlainSync()
                                            looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                            parseAwaitExpression(-, true)
                                              listener: beginAwaitExpression(await)
                                              parsePrecedenceExpression(await, 16, true)
                                                parseUnaryExpression(await, true)
                                                  parsePrimary(await, expression)
                                                    parseSendOrFunctionLiteral(await, expression)
                                                      parseSend(await, expression)
                                                        isNextIdentifier(await)
                                                        ensureIdentifier(await, expression)
                                                          listener: handleIdentifier(f, expression)
                                                        listener: handleNoTypeArguments())
                                                        parseArgumentsOpt(f)
                                                          listener: handleNoArguments())
                                                        listener: handleSend(f, ))
                                              inAsync()
                                              reportRecoverableError(await, AwaitNotAsync)
                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                        listener: endBinaryExpression(-)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, !)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(!)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrecedenceExpression(!, 16, true)
                            parseUnaryExpression(!, true)
                              inPlainSync()
                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                              parseAwaitExpression(!, true)
                                listener: beginAwaitExpression(await)
                                parsePrecedenceExpression(await, 16, true)
                                  parseUnaryExpression(await, true)
                                    parsePrimary(await, expression)
                                      parseSendOrFunctionLiteral(await, expression)
                                        parseSend(await, expression)
                                          isNextIdentifier(await)
                                          ensureIdentifier(await, expression)
                                            listener: handleIdentifier(f, expression)
                                          listener: handleNoTypeArguments(^)
                                          parseArgumentsOpt(f)
                                            listener: handleNoArguments(^)
                                          listener: handleSend(f, ^)
                                inAsync()
                                reportRecoverableError(await, AwaitNotAsync)
                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                          listener: handleUnaryPrefixExpression(!)
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrecedenceExpression(!, 16, true)
                              parseUnaryExpression(!, true)
                                inPlainSync()
                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                parseAwaitExpression(!, true)
                                  listener: beginAwaitExpression(await)
                                  parsePrecedenceExpression(await, 16, true)
                                    parseUnaryExpression(await, true)
                                      parsePrimary(await, expression)
                                        parseSendOrFunctionLiteral(await, expression)
                                          parseSend(await, expression)
                                            isNextIdentifier(await)
                                            ensureIdentifier(await, expression)
                                              listener: handleIdentifier(f, expression)
                                            listener: handleNoTypeArguments(;)
                                            parseArgumentsOpt(f)
                                              listener: handleNoArguments(;)
                                            listener: handleSend(f, ;)
                                  inAsync()
                                  reportRecoverableError(await, AwaitNotAsync)
                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
                                  listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
                            listener: handleUnaryPrefixExpression(!)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(f)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, print)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrecedenceExpression(!, 16, true)
                                            parseUnaryExpression(!, true)
                                              inPlainSync()
                                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                              parseAwaitExpression(!, true)
                                                listener: beginAwaitExpression(await)
                                                parsePrecedenceExpression(await, 16, true)
                                                  parseUnaryExpression(await, true)
                                                    parsePrimary(await, expression)
                                                      parseSendOrFunctionLiteral(await, expression)
                                                        parseSend(await, expression)
                                                          isNextIdentifier(await)
                                                          ensureIdentifier(await, expression)
                                                            listener: handleIdentifier(f, expression)
                                                          listener: handleNoTypeArguments(^)
                                                          parseArgumentsOpt(f)
                                                            listener: handleNoArguments(^)
                                                          listener: handleSend(f, ^)
                                                inAsync()
                                                reportRecoverableError(await, AwaitNotAsync)
                                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
                                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                          listener: handleUnaryPrefixExpression(!)
                                        listener: beginBinaryExpression(^)
                                        parsePrecedenceExpression(^, 11, true)
                                          parseUnaryExpression(^, true)
                                            parsePrecedenceExpression(!, 16, true)
                                              parseUnaryExpression(!, true)
                                                inPlainSync()
                                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                                parseAwaitExpression(!, true)
                                                  listener: beginAwaitExpression(await)
                                                  parsePrecedenceExpression(await, 16, true)
                                                    parseUnaryExpression(await, true)
                                                      parsePrimary(await, expression)
                                                        parseSendOrFunctionLiteral(await, expression)
                                                          parseSend(await, expression)
                                                            isNextIdentifier(await)
                                                            ensureIdentifier(await, expression)
                                                              listener: handleIdentifier(f, expression)
                                                            listener: handleNoTypeArguments())
                                                            parseArgumentsOpt(f)
                                                              listener: handleNoArguments())
                                                            listener: handleSend(f, ))
                                                  inAsync()
                                                  reportRecoverableError(await, AwaitNotAsync)
                                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
                                                  listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
                                            listener: handleUnaryPrefixExpression(!)
                                        listener: endBinaryExpression(^)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(x)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(x)
                  listener: handleType(await, null)
                  listener: beginVariablesDeclaration(x, null, null)
                  parseVariablesDeclarationRest(await, true)
                    parseOptionallyInitializedIdentifier(await)
                      ensureIdentifier(await, localVariableDeclaration)
                        listener: handleIdentifier(x, localVariableDeclaration)
                      listener: beginInitializedIdentifier(x)
                      parseVariableInitializerOpt(x)
                        listener: handleNoVariableInitializer(x)
                      listener: endInitializedIdentifier(x)
                    ensureSemicolon(x)
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(y)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(y)
                  listener: handleType(await, null)
                  listener: beginVariablesDeclaration(y, null, null)
                  parseVariablesDeclarationRest(await, true)
                    parseOptionallyInitializedIdentifier(await)
                      ensureIdentifier(await, localVariableDeclaration)
                        listener: handleIdentifier(y, localVariableDeclaration)
                      listener: beginInitializedIdentifier(y)
                      parseVariableInitializerOpt(y)
                        listener: handleNoVariableInitializer(y)
                      listener: endInitializedIdentifier(y)
                    parseOptionallyInitializedIdentifier(,)
                      ensureIdentifier(,, localVariableDeclaration)
                        listener: handleIdentifier(z, localVariableDeclaration)
                      listener: beginInitializedIdentifier(z)
                      parseVariableInitializerOpt(z)
                        listener: handleNoVariableInitializer(z)
                      listener: endInitializedIdentifier(z)
                    ensureSemicolon(z)
                    listener: endVariablesDeclaration(2, ;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(x2)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(x2)
                  listener: handleType(await, null)
                  listener: beginVariablesDeclaration(x2, null, null)
                  parseVariablesDeclarationRest(await, true)
                    parseOptionallyInitializedIdentifier(await)
                      ensureIdentifier(await, localVariableDeclaration)
                        listener: handleIdentifier(x2, localVariableDeclaration)
                      listener: beginInitializedIdentifier(x2)
                      parseVariableInitializerOpt(x2)
                        listener: beginVariableInitializer(=)
                        parseExpression(=)
                          parsePrecedenceExpression(=, 1, true)
                            parseUnaryExpression(=, true)
                              inPlainSync()
                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                              parsePrimary(=, expression)
                                inPlainSync()
                                parseSendOrFunctionLiteral(=, expression)
                                  parseSend(=, expression)
                                    isNextIdentifier(=)
                                    ensureIdentifier(=, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(await, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(await)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(await, ;)
                        listener: endVariableInitializer(=)
                      listener: endInitializedIdentifier(x2)
                    ensureSemicolon(await)
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(y2)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(y2)
                  listener: handleType(await, null)
                  listener: beginVariablesDeclaration(y2, null, null)
                  parseVariablesDeclarationRest(await, true)
                    parseOptionallyInitializedIdentifier(await)
                      ensureIdentifier(await, localVariableDeclaration)
                        listener: handleIdentifier(y2, localVariableDeclaration)
                      listener: beginInitializedIdentifier(y2)
                      parseVariableInitializerOpt(y2)
                        listener: beginVariableInitializer(=)
                        parseExpression(=)
                          parsePrecedenceExpression(=, 1, true)
                            parseUnaryExpression(=, true)
                              inPlainSync()
                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                              parsePrimary(=, expression)
                                inPlainSync()
                                parseSendOrFunctionLiteral(=, expression)
                                  parseSend(=, expression)
                                    isNextIdentifier(=)
                                    ensureIdentifier(=, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(await, expression)
                                    listener: handleNoTypeArguments(,)
                                    parseArgumentsOpt(await)
                                      listener: handleNoArguments(,)
                                    listener: handleSend(await, ,)
                        listener: endVariableInitializer(=)
                      listener: endInitializedIdentifier(y2)
                    parseOptionallyInitializedIdentifier(,)
                      ensureIdentifier(,, localVariableDeclaration)
                        listener: handleIdentifier(z2, localVariableDeclaration)
                      listener: beginInitializedIdentifier(z2)
                      parseVariableInitializerOpt(z2)
                        listener: beginVariableInitializer(=)
                        parseExpression(=)
                          parsePrecedenceExpression(=, 1, true)
                            parseUnaryExpression(=, true)
                              inPlainSync()
                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                              parsePrimary(=, expression)
                                inPlainSync()
                                parseSendOrFunctionLiteral(=, expression)
                                  parseSend(=, expression)
                                    isNextIdentifier(=)
                                    ensureIdentifier(=, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(await, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(await)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(await, ;)
                        listener: endVariableInitializer(=)
                      listener: endInitializedIdentifier(z2)
                    ensureSemicolon(await)
                    listener: endVariablesDeclaration(2, ;)
          notEofOrValue(}, await)
          parseStatement(;)
            parseStatementX(;)
              inPlainSync()
              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(foo)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleNoTypeVariables(()
                  listener: beginLocalFunctionDeclaration(await)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(foo)
                  listener: handleType(await, null)
                  parseNamedFunctionRest(await, await, foo, false)
                    listener: beginFunctionName(foo)
                    ensureIdentifier(await, localFunctionDeclaration)
                      listener: handleIdentifier(foo, localFunctionDeclaration)
                    listener: endFunctionName(await, ()
                    parseFormalParametersRequiredOpt(foo, MemberKind.Local)
                      parseFormalParametersRest((, MemberKind.Local)
                        listener: beginFormalParameters((, MemberKind.Local)
                        parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.Local)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.Local, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(bar)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(bar, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
                        listener: endFormalParameters(1, (, ), MemberKind.Local)
                    parseInitializersOpt())
                      listener: handleNoInitializers()
                    parseAsyncOptBody(), false, false)
                      parseAsyncModifierOpt())
                        listener: handleAsyncModifier(null, null)
                        inPlainSync()
                      parseFunctionBody(), false, false)
                        listener: beginBlockFunctionBody({)
                        notEofOrValue(}, return)
                        parseStatement({)
                          parseStatementX({)
                            parseReturnStatement({)
                              listener: beginReturnStatement(return)
                              parseExpression(return)
                                parsePrecedenceExpression(return, 1, true)
                                  parseUnaryExpression(return, true)
                                    parsePrimary(return, expression)
                                      parseNewExpression(return)
                                        isNextIdentifier(new)
                                        listener: beginNewExpression(new)
                                        parseConstructorReference(new, ConstructorReferenceContext.New, null)
                                          ensureIdentifier(new, constructorReference)
                                            inPlainSync()
                                            listener: handleIdentifier(await, constructorReference)
                                          listener: beginConstructorReference(await)
                                          parseQualifiedRestOpt(await, constructorReferenceContinuation)
                                          listener: handleNoTypeArguments(()
                                          listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                          listener: endConstructorReference(await, null, (, ConstructorReferenceContext.New)
                                        parseConstructorInvocationArguments(await)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            listener: endArguments(0, (, ))
                                        listener: endNewExpression(new)
                              ensureSemicolon())
                              listener: endReturnStatement(true, return, ;)
                              inGenerator()
                        notEofOrValue(}, })
                        listener: endBlockFunctionBody(1, {, })
                    listener: endLocalFunctionDeclaration(})
          notEofOrValue(}, await)
          parseStatement(})
            parseStatementX(})
              inPlainSync()
              looksLikeAwaitExpression(}, AwaitOrYieldContext.Statement)
                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
              parseExpressionStatementOrDeclaration(}, false)
                parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                  looksLikeLocalFunction(bar)
                  listener: beginMetadataStar(await)
                  listener: endMetadataStar(0)
                  listener: handleNoTypeVariables(()
                  listener: beginLocalFunctionDeclaration(await)
                  listener: handleIdentifier(await, typeReference)
                  listener: handleNoTypeArguments(bar)
                  listener: handleType(await, null)
                  parseNamedFunctionRest(await, await, bar, false)
                    listener: beginFunctionName(bar)
                    ensureIdentifier(await, localFunctionDeclaration)
                      listener: handleIdentifier(bar, localFunctionDeclaration)
                    listener: endFunctionName(await, ()
                    parseFormalParametersRequiredOpt(bar, MemberKind.Local)
                      parseFormalParametersRest((, MemberKind.Local)
                        listener: beginFormalParameters((, MemberKind.Local)
                        parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.Local)
                          parseMetadataStar(()
                            listener: beginMetadataStar(await)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
                          listener: handleIdentifier(await, typeReference)
                          listener: handleNoTypeArguments(baz)
                          listener: handleType(await, null)
                          ensureIdentifier(await, formalParameterDeclaration)
                            listener: handleIdentifier(baz, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue(,)
                          listener: endFormalParameter(null, null, null, baz, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
                        parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.Local)
                          parseMetadataStar(,)
                            listener: beginMetadataStar(await)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
                          listener: handleIdentifier(await, typeReference)
                          listener: handleNoTypeArguments(baz2)
                          listener: handleType(await, null)
                          ensureIdentifier(await, formalParameterDeclaration)
                            listener: handleIdentifier(baz2, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue(,)
                          listener: endFormalParameter(null, null, null, baz2, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
                        parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.Local)
                          parseMetadataStar(,)
                            listener: beginMetadataStar(await)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
                          listener: handleIdentifier(await, typeReference)
                          listener: handleNoTypeArguments(baz3)
                          listener: handleType(await, null)
                          ensureIdentifier(await, formalParameterDeclaration)
                            listener: handleIdentifier(baz3, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, null, baz3, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
                        listener: endFormalParameters(3, (, ), MemberKind.Local)
                    parseInitializersOpt())
                      listener: handleNoInitializers()
                    parseAsyncOptBody(), false, false)
                      parseAsyncModifierOpt())
                        listener: handleAsyncModifier(null, null)
                        inPlainSync()
                      parseFunctionBody(), false, false)
                        listener: beginBlockFunctionBody({)
                        notEofOrValue(}, return)
                        parseStatement({)
                          parseStatementX({)
                            parseReturnStatement({)
                              listener: beginReturnStatement(return)
                              parseExpression(return)
                                parsePrecedenceExpression(return, 1, true)
                                  parseUnaryExpression(return, true)
                                    parsePrimary(return, expression)
                                      parseSendOrFunctionLiteral(return, expression)
                                        parseSend(return, expression)
                                          isNextIdentifier(return)
                                          ensureIdentifier(return, expression)
                                            listener: handleIdentifier(baz, expression)
                                          listener: handleNoTypeArguments(;)
                                          parseArgumentsOpt(baz)
                                            listener: handleNoArguments(;)
                                          listener: handleSend(baz, ;)
                              ensureSemicolon(baz)
                              listener: endReturnStatement(true, return, ;)
                              inGenerator()
                        notEofOrValue(}, })
                        listener: endBlockFunctionBody(1, {, })
                    listener: endLocalFunctionDeclaration(})
          notEofOrValue(}, })
          listener: endBlockFunctionBody(31, {, })
        listener: endTopLevelMethod(void, null, })
  listener: endTopLevelDeclaration(bool)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(bool)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(bool)
      parseTopLevelMethod(}, null, null, }, Instance of 'SimpleType', null, xor, false)
        listener: beginTopLevelMethod(}, null, null)
        listener: handleIdentifier(bool, typeReference)
        listener: handleNoTypeArguments(xor)
        listener: handleType(bool, null)
        ensureIdentifierPotentiallyRecovered(bool, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(xor, topLevelFunctionDeclaration)
        parseMethodTypeVar(xor)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(xor, xor, false, MemberKind.TopLevelMethod)
          parseFormalParameters(xor, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(bool)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(bool, typeReference)
                listener: handleNoTypeArguments(a)
                listener: handleType(bool, null)
                ensureIdentifier(bool, formalParameterDeclaration)
                  listener: handleIdentifier(a, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue(,)
                listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
              parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
                parseMetadataStar(,)
                  listener: beginMetadataStar(bool)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(bool, typeReference)
                listener: handleNoTypeArguments(b)
                listener: handleType(bool, null)
                ensureIdentifier(bool, formalParameterDeclaration)
                  listener: handleIdentifier(b, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue(,)
                listener: endFormalParameter(null, null, null, b, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
              parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
                parseMetadataStar(,)
                  listener: beginMetadataStar(bool)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(bool, typeReference)
                listener: handleNoTypeArguments(c)
                listener: handleType(bool, null)
                ensureIdentifier(bool, formalParameterDeclaration)
                  listener: handleIdentifier(c, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, null, c, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
              listener: endFormalParameters(3, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, return)
          parseStatement({)
            parseStatementX({)
              parseReturnStatement({)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseSendOrFunctionLiteral(return, expression)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              listener: handleIdentifier(b, expression)
                            listener: handleNoTypeArguments(^)
                            parseArgumentsOpt(b)
                              listener: handleNoArguments(^)
                            listener: handleSend(b, ^)
                    listener: beginBinaryExpression(^)
                    parsePrecedenceExpression(^, 11, true)
                      parseUnaryExpression(^, true)
                        parsePrimary(^, expression)
                          parseSendOrFunctionLiteral(^, expression)
                            parseSend(^, expression)
                              isNextIdentifier(^)
                              ensureIdentifier(^, expression)
                                listener: handleIdentifier(b, expression)
                              listener: handleNoTypeArguments(^)
                              parseArgumentsOpt(b)
                                listener: handleNoArguments(^)
                              listener: handleSend(b, ^)
                    listener: endBinaryExpression(^)
                    listener: beginBinaryExpression(^)
                    parsePrecedenceExpression(^, 11, true)
                      parseUnaryExpression(^, true)
                        parsePrimary(^, expression)
                          parseSendOrFunctionLiteral(^, expression)
                            parseSend(^, expression)
                              isNextIdentifier(^)
                              ensureIdentifier(^, expression)
                                listener: handleIdentifier(c, expression)
                              listener: handleNoTypeArguments(;)
                              parseArgumentsOpt(c)
                                listener: handleNoArguments(;)
                              listener: handleSend(c, ;)
                    listener: endBinaryExpression(^)
                ensureSemicolon(c)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(bool, null, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(await, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, await)
        parseClass(await, class, class, await)
          parseClassHeaderOpt(await, class, class)
            parseClassExtendsOpt(await)
              listener: handleNoType(await)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(await)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(await)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(await, DeclarationKind.Class, await)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(Future)
  listener: endCompilationUnit(4, )