parseUnit(int)
  skipErrorTokens(int)
  listener: beginCompilationUnit(int)
  syntheticPreviousToken(int)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(, null, , Instance of 'SimpleType', null, abstract, false)
        listener: beginTopLevelMethod(, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(abstract)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(abstract, topLevelFunctionDeclaration)
        parseMethodTypeVar(abstract)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(abstract, abstract, false, MemberKind.TopLevelMethod)
          parseFormalParameters(abstract, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(abstract, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(abstract)
                              parseArguments(abstract)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(abstract, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, as, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(as)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(as, topLevelFunctionDeclaration)
        parseMethodTypeVar(as)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(as, as, false, MemberKind.TopLevelMethod)
          parseFormalParameters(as, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(as, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(as)
                              parseArguments(as)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(as, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(assert)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, assert, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(assert)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert)
          listener: handleIdentifier(assert, topLevelFunctionDeclaration)
        parseMethodTypeVar(assert)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(assert, assert, false, MemberKind.TopLevelMethod)
          parseFormalParameters(assert, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseAssert(return, Assert.Expression)
                          listener: beginAssert(assert, Assert.Expression)
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      isNextIdentifier(()
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          reportRecoverableError(assert, AssertAsExpression)
                            listener: handleRecoverableError(AssertAsExpression, assert, assert)
                          listener: endAssert(assert, Assert.Expression, (, null, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, async, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(async)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(async, topLevelFunctionDeclaration)
        parseMethodTypeVar(async)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(async, async, false, MemberKind.TopLevelMethod)
          parseFormalParameters(async, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(async, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(async)
                              parseArguments(async)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(async, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, await, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(await)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(await, topLevelFunctionDeclaration)
        parseMethodTypeVar(await)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(await, await, false, MemberKind.TopLevelMethod)
          parseFormalParameters(await, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      inPlainSync()
                      looksLikeAwaitExpression(return)
                        looksLikeExpression(await)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(await, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(await)
                              parseArguments(await)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(await, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(break)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, break, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(break)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break)
          listener: handleIdentifier(break, topLevelFunctionDeclaration)
        parseMethodTypeVar(break)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(break, break, false, MemberKind.TopLevelMethod)
          parseFormalParameters(break, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(break)
                          parseArgumentsOpt()
                            listener: handleNoArguments(break)
                          listener: handleSend(, break)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, break)
          parseStatement(;)
            parseStatementX(;)
              parseBreakStatement(;)
                isBreakAllowed()
                reportRecoverableError(break, BreakOutsideOfLoop)
                  listener: handleRecoverableError(BreakOutsideOfLoop, break, break)
                ensureSemicolon(break)
                  reportRecoverableError(break, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
                  rewriter()
                listener: handleBreakStatement(false, break, ;)
          notEofOrValue(}, ()
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(;)
                              parseParenthesizedExpression(;)
                                parseExpressionInParenthesis(;)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(case)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, case, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(case)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
          listener: handleIdentifier(case, topLevelFunctionDeclaration)
        parseMethodTypeVar(case)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(case, case, false, MemberKind.TopLevelMethod)
          parseFormalParameters(case, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
                            listener: handleIdentifier(case, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(case)
                            parseArguments(case)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(case, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(catch)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, catch, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(catch)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
          listener: handleIdentifier(catch, topLevelFunctionDeclaration)
        parseMethodTypeVar(catch)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(catch, catch, false, MemberKind.TopLevelMethod)
          parseFormalParameters(catch, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
                            listener: handleIdentifier(catch, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(catch)
                            parseArguments(catch)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(catch, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(class)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, class, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(class)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
          listener: handleIdentifier(class, topLevelFunctionDeclaration)
        parseMethodTypeVar(class)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(class, class, false, MemberKind.TopLevelMethod)
          parseFormalParameters(class, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
                            listener: handleIdentifier(class, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(class)
                            parseArguments(class)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(class, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(const)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, const, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(const)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const)
          listener: handleIdentifier(const, topLevelFunctionDeclaration)
        parseMethodTypeVar(const)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(const, const, false, MemberKind.TopLevelMethod)
          parseFormalParameters(const, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseConstExpression(return)
                          listener: beginConstExpression(const)
                          parseConstructorReference(const, ConstructorReferenceContext.Const, null)
                            ensureIdentifier(const, constructorReference)
                              insertSyntheticIdentifier(const, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null)
                                reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}])
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                                rewriter()
                              listener: handleIdentifier(, constructorReference)
                            listener: beginConstructorReference()
                            parseQualifiedRestOpt(, constructorReferenceContinuation)
                            listener: handleNoTypeArguments(()
                            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                            listener: endConstructorReference(, null, (, ConstructorReferenceContext.Const)
                          parseConstructorInvocationArguments()
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          isNextIdentifier(()
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              listener: endArguments(1, (, ))
                          listener: endConstExpression(const)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(continue)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, continue, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(continue)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue)
          listener: handleIdentifier(continue, topLevelFunctionDeclaration)
        parseMethodTypeVar(continue)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(continue, continue, false, MemberKind.TopLevelMethod)
          parseFormalParameters(continue, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(continue)
                          parseArgumentsOpt()
                            listener: handleNoArguments(continue)
                          listener: handleSend(, continue)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, continue)
          parseStatement(;)
            parseStatementX(;)
              parseContinueStatement(;)
                isContinueAllowed()
                reportRecoverableError(continue, ContinueOutsideOfLoop)
                  listener: handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
                ensureSemicolon(continue)
                  reportRecoverableError(continue, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
                  rewriter()
                listener: handleContinueStatement(false, continue, ;)
          notEofOrValue(}, ()
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(;)
                              parseParenthesizedExpression(;)
                                parseExpressionInParenthesis(;)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, covariant, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(covariant)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(covariant, topLevelFunctionDeclaration)
        parseMethodTypeVar(covariant)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(covariant, covariant, false, MemberKind.TopLevelMethod)
          parseFormalParameters(covariant, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(covariant, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(covariant)
                              parseArguments(covariant)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(covariant, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(default)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, default, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(default)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
          listener: handleIdentifier(default, topLevelFunctionDeclaration)
        parseMethodTypeVar(default)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(default, default, false, MemberKind.TopLevelMethod)
          parseFormalParameters(default, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
                            listener: handleIdentifier(default, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(default)
                            parseArguments(default)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(default, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, deferred, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(deferred)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(deferred, topLevelFunctionDeclaration)
        parseMethodTypeVar(deferred)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(deferred, deferred, false, MemberKind.TopLevelMethod)
          parseFormalParameters(deferred, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(deferred, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(deferred)
                              parseArguments(deferred)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(deferred, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(do)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, do, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(do)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do)
          listener: handleIdentifier(do, topLevelFunctionDeclaration)
        parseMethodTypeVar(do)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(do, do, false, MemberKind.TopLevelMethod)
          parseFormalParameters(do, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(do)
                          parseArgumentsOpt()
                            listener: handleNoArguments(do)
                          listener: handleSend(, do)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, do)
          parseStatement(;)
            parseStatementX(;)
              parseDoWhileStatement(;)
                listener: beginDoWhileStatement(do)
                listener: beginDoWhileStatementBody(()
                parseStatement(do)
                  parseStatementX(do)
                    parseExpressionStatementOrDeclaration(do, false)
                      parseExpressionStatementOrDeclarationAfterModifiers(do, do, null, null, null, false)
                        looksLikeLocalFunction(()
                        parseExpressionStatement(do)
                          parseExpression(do)
                            parsePrecedenceExpression(do, 1, true)
                              parseUnaryExpression(do, true)
                                parsePrimary(do, expression)
                                  parseParenthesizedExpressionOrFunctionLiteral(do)
                                    parseParenthesizedExpression(do)
                                      parseExpressionInParenthesis(do)
                                        parseExpressionInParenthesisRest(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      isNextIdentifier(()
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          ensureCloseParen(1, ()
                                      listener: handleParenthesizedExpression(()
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: handleExpressionStatement(;)
                listener: endDoWhileStatementBody(;)
                reportRecoverableError(}, Message[ExpectedButGot, Expected 'while' before this., null, {string: while}])
                  listener: handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, })
                rewriter()
                ensureParenthesizedCondition(while)
                  reportRecoverableError(}, Message[ExpectedToken, Expected to find '('., null, {string: (}])
                    listener: handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, })
                  rewriter()
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSend((, expression)
                              isNextIdentifier(()
                              ensureIdentifier((, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments())
                              parseArgumentsOpt()
                                listener: handleNoArguments())
                              listener: handleSend(, ))
                    ensureCloseParen(, ()
                  listener: handleParenthesizedCondition(()
                ensureSemicolon())
                  reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
                  rewriter()
                listener: endDoWhileStatement(do, while, ;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, dynamic, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(dynamic)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(dynamic, topLevelFunctionDeclaration)
        parseMethodTypeVar(dynamic)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(dynamic, dynamic, false, MemberKind.TopLevelMethod)
          parseFormalParameters(dynamic, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(dynamic, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(dynamic)
                              parseArguments(dynamic)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(dynamic, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(else)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, else, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(else)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else)
          listener: handleIdentifier(else, topLevelFunctionDeclaration)
        parseMethodTypeVar(else)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(else, else, false, MemberKind.TopLevelMethod)
          parseFormalParameters(else, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(else)
                          parseArgumentsOpt()
                            listener: handleNoArguments(else)
                          listener: handleSend(, else)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, else)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(else)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            inPlainSync()
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments(else)
                              parseArgumentsOpt()
                                listener: handleNoArguments(else)
                              listener: handleSend(, else)
                    ensureSemicolon()
                      reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                      rewriter()
                    listener: handleExpressionStatement(;)
          reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], else, else)
          notEofOrValue(}, ()
          parseStatement(else)
            parseStatementX(else)
              parseExpressionStatementOrDeclaration(else, false)
                parseExpressionStatementOrDeclarationAfterModifiers(else, else, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(else)
                    parseExpression(else)
                      parsePrecedenceExpression(else, 1, true)
                        parseUnaryExpression(else, true)
                          parsePrimary(else, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(else)
                              parseParenthesizedExpression(else)
                                parseExpressionInParenthesis(else)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(enum)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, enum, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(enum)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
          listener: handleIdentifier(enum, topLevelFunctionDeclaration)
        parseMethodTypeVar(enum)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(enum, enum, false, MemberKind.TopLevelMethod)
          parseFormalParameters(enum, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
                            listener: handleIdentifier(enum, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(enum)
                            parseArguments(enum)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(enum, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, export, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(export)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(export, topLevelFunctionDeclaration)
        parseMethodTypeVar(export)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(export, export, false, MemberKind.TopLevelMethod)
          parseFormalParameters(export, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(export, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(export)
                              parseArguments(export)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(export, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(extends)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, extends, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(extends)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
          listener: handleIdentifier(extends, topLevelFunctionDeclaration)
        parseMethodTypeVar(extends)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(extends, extends, false, MemberKind.TopLevelMethod)
          parseFormalParameters(extends, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
                            listener: handleIdentifier(extends, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(extends)
                            parseArguments(extends)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(extends, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, extension, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(extension)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(extension, topLevelFunctionDeclaration)
        parseMethodTypeVar(extension)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(extension, extension, false, MemberKind.TopLevelMethod)
          parseFormalParameters(extension, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(extension, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(extension)
                              parseArguments(extension)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(extension, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, external, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(external)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(external, topLevelFunctionDeclaration)
        parseMethodTypeVar(external)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(external, external, false, MemberKind.TopLevelMethod)
          parseFormalParameters(external, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(external, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(external)
                              parseArguments(external)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(external, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, factory, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(factory)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(factory, topLevelFunctionDeclaration)
        parseMethodTypeVar(factory)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(factory, factory, false, MemberKind.TopLevelMethod)
          parseFormalParameters(factory, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(factory, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(factory)
                              parseArguments(factory)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(factory, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(false)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, false, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(false)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false)
          listener: handleIdentifier(false, topLevelFunctionDeclaration)
        parseMethodTypeVar(false)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(false, false, false, MemberKind.TopLevelMethod)
          parseFormalParameters(false, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseLiteralBool(return)
                          listener: handleLiteralBool(false)
                    parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false)
                      listener: handleNoTypeArguments(()
                      parseArguments(false)
                        parseArgumentsRest(()
                          listener: beginArguments(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      isNextIdentifier(()
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          listener: endArguments(1, (, ))
                      listener: handleSend((, ))
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(final)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, final, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(final)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final)
          listener: handleIdentifier(final, topLevelFunctionDeclaration)
        parseMethodTypeVar(final)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(final, final, false, MemberKind.TopLevelMethod)
          parseFormalParameters(final, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(final)
                          parseArgumentsOpt()
                            listener: handleNoArguments(final)
                          listener: handleSend(, final)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, final)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(final, ;, null, final, null, false)
                looksLikeLocalFunction(()
                listener: beginMetadataStar(final)
                listener: endMetadataStar(0)
                listener: handleNoType(final)
                listener: beginVariablesDeclaration((, null, final)
                parseVariablesDeclarationRest(final, true)
                  parseOptionallyInitializedIdentifier(final)
                    ensureIdentifier(final, localVariableDeclaration)
                      reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                      rewriter()
                      listener: handleIdentifier(, localVariableDeclaration)
                    listener: beginInitializedIdentifier()
                    parseVariableInitializerOpt()
                      listener: handleNoVariableInitializer()
                    listener: endInitializedIdentifier()
                  ensureSemicolon()
                    reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
                    rewriter()
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, x)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(x)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(x, expression)
                              listener: handleNoTypeArguments(-)
                              parseArgumentsOpt(x)
                                listener: handleNoArguments(-)
                              listener: handleSend(x, -)
                      listener: beginBinaryExpression(-)
                      parsePrecedenceExpression(-, 14, true)
                        parseUnaryExpression(-, true)
                          parsePrimary(-, expression)
                            parseLiteralInt(-)
                              listener: handleLiteralInt(1)
                      listener: endBinaryExpression(-)
                  ensureSemicolon(1)
                    reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, ))
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction())
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments())
                              parseArgumentsOpt()
                                listener: handleNoArguments())
                              listener: handleSend(, ))
                    ensureSemicolon()
                      reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                      rewriter()
                    listener: handleExpressionStatement(;)
          reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
          notEofOrValue(}, +)
          parseStatement())
            parseStatementX())
              parseExpressionStatementOrDeclaration(), false)
                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                  looksLikeLocalFunction(+)
                  parseExpressionStatement())
                    parseExpression())
                      parsePrecedenceExpression(), 1, true)
                        parseUnaryExpression(), true)
                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                            reportRecoverableError(+, UnsupportedPrefixPlus)
                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                            rewriter()
                          parsePrimary(), expression)
                            parseSendOrFunctionLiteral(), expression)
                              parseSend(), expression)
                                isNextIdentifier())
                                ensureIdentifier(), expression)
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt()
                                  listener: handleNoArguments(+)
                                listener: handleSend(, +)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(finally)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, finally, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(finally)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
          listener: handleIdentifier(finally, topLevelFunctionDeclaration)
        parseMethodTypeVar(finally)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(finally, finally, false, MemberKind.TopLevelMethod)
          parseFormalParameters(finally, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
                            listener: handleIdentifier(finally, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(finally)
                            parseArguments(finally)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(finally, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(for)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, for, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(for)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for)
          listener: handleIdentifier(for, topLevelFunctionDeclaration)
        parseMethodTypeVar(for)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(for, for, false, MemberKind.TopLevelMethod)
          parseFormalParameters(for, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(for)
                          parseArgumentsOpt()
                            listener: handleNoArguments(for)
                          listener: handleSend(, for)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, for)
          parseStatement(;)
            parseStatementX(;)
              parseForStatement(;, null)
                listener: beginForStatement(for)
                parseForLoopPartsStart(null, for)
                  parseExpressionStatementOrDeclaration((, true)
                    parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, true)
                parseForLoopPartsMid((, null, for)
                  parseExpression(()
                    parsePrecedenceExpression((, 1, true)
                      parseUnaryExpression((, true)
                        parsePrimary((, expression)
                          parseSendOrFunctionLiteral((, expression)
                            parseSend((, expression)
                              isNextIdentifier(()
                              ensureIdentifier((, expression)
                                listener: handleIdentifier(x, expression)
                              listener: handleNoTypeArguments(-)
                              parseArgumentsOpt(x)
                                listener: handleNoArguments(-)
                              listener: handleSend(x, -)
                      listener: beginBinaryExpression(-)
                      parsePrecedenceExpression(-, 14, true)
                        parseUnaryExpression(-, true)
                          parsePrimary(-, expression)
                            parseLiteralInt(-)
                              listener: handleLiteralInt(1)
                      listener: endBinaryExpression(-)
                  listener: handleForInitializerExpressionStatement(1, false)
                parseForRest(null, 1, for)
                  parseForLoopPartsRest(1, for, null)
                    ensureSemicolon(1)
                      reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                      rewriter()
                    parseExpressionStatement(;)
                      parseExpression(;)
                        parsePrecedenceExpression(;, 1, true)
                          parseUnaryExpression(;, true)
                            parsePrimary(;, expression)
                              parseSend(;, expression)
                                isNextIdentifier(;)
                                ensureIdentifier(;, expression)
                                  reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                    listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                  rewriter()
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments())
                                parseArgumentsOpt()
                                  listener: handleNoArguments())
                                listener: handleSend(, ))
                      ensureSemicolon()
                        reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                        rewriter()
                      listener: handleExpressionStatement(;)
                    listener: handleForLoopParts(for, (, ;, 0)
                  listener: beginForStatementBody(+)
                  parseStatement())
                    parseStatementX())
                      parseExpressionStatementOrDeclaration(), false)
                        parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                          looksLikeLocalFunction(+)
                          parseExpressionStatement())
                            parseExpression())
                              parsePrecedenceExpression(), 1, true)
                                parseUnaryExpression(), true)
                                  rewriteAndRecover(), UnsupportedPrefixPlus, )
                                    reportRecoverableError(+, UnsupportedPrefixPlus)
                                      listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                    rewriter()
                                  parsePrimary(), expression)
                                    parseSendOrFunctionLiteral(), expression)
                                      parseSend(), expression)
                                        isNextIdentifier())
                                        ensureIdentifier(), expression)
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments(+)
                                        parseArgumentsOpt()
                                          listener: handleNoArguments(+)
                                        listener: handleSend(, +)
                                listener: beginBinaryExpression(+)
                                parsePrecedenceExpression(+, 14, true)
                                  parseUnaryExpression(+, true)
                                    parsePrimary(+, expression)
                                      parseLiteralInt(+)
                                        listener: handleLiteralInt(1)
                                listener: endBinaryExpression(+)
                            ensureSemicolon(1)
                            listener: handleExpressionStatement(;)
                  listener: endForStatementBody(})
                  listener: endForStatement(})
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, Function, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(Function)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(Function, topLevelFunctionDeclaration)
        parseMethodTypeVar(Function)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(Function, Function, false, MemberKind.TopLevelMethod)
          parseFormalParameters(Function, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(Function, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(Function)
                              parseArguments(Function)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(Function, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, get, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(get)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(get, topLevelFunctionDeclaration)
        parseMethodTypeVar(get)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(get, get, false, MemberKind.TopLevelMethod)
          parseFormalParameters(get, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(get, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(get)
                              parseArguments(get)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(get, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, hide, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(hide)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(hide, topLevelFunctionDeclaration)
        parseMethodTypeVar(hide)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(hide, hide, false, MemberKind.TopLevelMethod)
          parseFormalParameters(hide, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(hide, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(hide)
                              parseArguments(hide)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(hide, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(if)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, if, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(if)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if)
          listener: handleIdentifier(if, topLevelFunctionDeclaration)
        parseMethodTypeVar(if)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(if, if, false, MemberKind.TopLevelMethod)
          parseFormalParameters(if, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(if)
                          parseArgumentsOpt()
                            listener: handleNoArguments(if)
                          listener: handleSend(, if)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, if)
          parseStatement(;)
            parseStatementX(;)
              parseIfStatement(;)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(-)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(-)
                                listener: handleSend(x, -)
                        listener: beginBinaryExpression(-)
                        parsePrecedenceExpression(-, 14, true)
                          parseUnaryExpression(-, true)
                            parsePrimary(-, expression)
                              parseLiteralInt(-)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(-)
                    ensureCloseParen(1, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(+)
                parseStatement())
                  parseStatementX())
                    parseExpressionStatementOrDeclaration(), false)
                      parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                        looksLikeLocalFunction(+)
                        parseExpressionStatement())
                          parseExpression())
                            parsePrecedenceExpression(), 1, true)
                              parseUnaryExpression(), true)
                                rewriteAndRecover(), UnsupportedPrefixPlus, )
                                  reportRecoverableError(+, UnsupportedPrefixPlus)
                                    listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                  rewriter()
                                parsePrimary(), expression)
                                  parseSendOrFunctionLiteral(), expression)
                                    parseSend(), expression)
                                      isNextIdentifier())
                                      ensureIdentifier(), expression)
                                        listener: handleIdentifier(, expression)
                                      listener: handleNoTypeArguments(+)
                                      parseArgumentsOpt()
                                        listener: handleNoArguments(+)
                                      listener: handleSend(, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: handleExpressionStatement(;)
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, implements, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(implements)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(implements, topLevelFunctionDeclaration)
        parseMethodTypeVar(implements)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(implements, implements, false, MemberKind.TopLevelMethod)
          parseFormalParameters(implements, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(implements, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(implements)
                              parseArguments(implements)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(implements, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, import, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(import)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(import, topLevelFunctionDeclaration)
        parseMethodTypeVar(import)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(import, import, false, MemberKind.TopLevelMethod)
          parseFormalParameters(import, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(import, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(import)
                              parseArguments(import)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(import, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(in)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, in, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(in)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
          listener: handleIdentifier(in, topLevelFunctionDeclaration)
        parseMethodTypeVar(in)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(in, in, false, MemberKind.TopLevelMethod)
          parseFormalParameters(in, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
                            listener: handleIdentifier(in, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(in)
                            parseArguments(in)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(in, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, inout, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(inout)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(inout, topLevelFunctionDeclaration)
        parseMethodTypeVar(inout)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(inout, inout, false, MemberKind.TopLevelMethod)
          parseFormalParameters(inout, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(inout, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(inout)
                              parseArguments(inout)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(inout, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, interface, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(interface)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(interface, topLevelFunctionDeclaration)
        parseMethodTypeVar(interface)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(interface, interface, false, MemberKind.TopLevelMethod)
          parseFormalParameters(interface, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(interface, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(interface)
                              parseArguments(interface)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(interface, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(is)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, is, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(is)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is)
          listener: handleIdentifier(is, topLevelFunctionDeclaration)
        parseMethodTypeVar(is)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(is, is, false, MemberKind.TopLevelMethod)
          parseFormalParameters(is, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(is)
                          parseArgumentsOpt()
                            listener: handleNoArguments(is)
                          listener: handleSend(, is)
                    parseIsOperatorRest()
                      listener: beginIsOperatorType(is)
                      computeTypeAfterIsOrAs(is)
                      reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                        listener: handleRecoverableError(Message[ExpectedType, Expected a type, but got '('., null, {lexeme: (}], (, ()
                      rewriter()
                      listener: handleIdentifier(, typeReference)
                      listener: handleNoTypeArguments(()
                      listener: handleType(, null)
                      listener: endIsOperatorType(is)
                      listener: handleIsOperator(is, null)
                      skipChainedAsIsOperators()
                ensureSemicolon()
                  reportRecoverableError(is, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], is, is)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, ()
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(;)
                              parseParenthesizedExpression(;)
                                parseExpressionInParenthesis(;)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, late, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(late)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(late, topLevelFunctionDeclaration)
        parseMethodTypeVar(late)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(late, late, false, MemberKind.TopLevelMethod)
          parseFormalParameters(late, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(late, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(late)
                              parseArguments(late)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(late, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, library, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(library)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(library, topLevelFunctionDeclaration)
        parseMethodTypeVar(library)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(library, library, false, MemberKind.TopLevelMethod)
          parseFormalParameters(library, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(library, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(library)
                              parseArguments(library)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(library, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, mixin, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(mixin)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(mixin, topLevelFunctionDeclaration)
        parseMethodTypeVar(mixin)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(mixin, mixin, false, MemberKind.TopLevelMethod)
          parseFormalParameters(mixin, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(mixin, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(mixin)
                              parseArguments(mixin)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(mixin, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, native, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(native)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(native, topLevelFunctionDeclaration)
        parseMethodTypeVar(native)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(native, native, false, MemberKind.TopLevelMethod)
          parseFormalParameters(native, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(native, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(native)
                              parseArguments(native)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(native, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(new)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, new, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(new)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new)
          listener: handleIdentifier(new, topLevelFunctionDeclaration)
        parseMethodTypeVar(new)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(new, new, false, MemberKind.TopLevelMethod)
          parseFormalParameters(new, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          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)
                              insertSyntheticIdentifier(new, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null)
                                reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}])
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                                rewriter()
                              listener: handleIdentifier(, constructorReference)
                            listener: beginConstructorReference()
                            parseQualifiedRestOpt(, constructorReferenceContinuation)
                            listener: handleNoTypeArguments(()
                            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                            listener: endConstructorReference(, null, (, ConstructorReferenceContext.New)
                          parseConstructorInvocationArguments()
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          isNextIdentifier(()
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              listener: endArguments(1, (, ))
                          listener: endNewExpression(new)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(null)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, null, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(null)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null)
          listener: handleIdentifier(null, topLevelFunctionDeclaration)
        parseMethodTypeVar(null)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(null, null, false, MemberKind.TopLevelMethod)
          parseFormalParameters(null, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseLiteralNull(return)
                          listener: handleLiteralNull(null)
                    parseArgumentOrIndexStar(null, Instance of 'NoTypeParamOrArg', false)
                      listener: handleNoTypeArguments(()
                      parseArguments(null)
                        parseArgumentsRest(()
                          listener: beginArguments(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      isNextIdentifier(()
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          listener: endArguments(1, (, ))
                      listener: handleSend((, ))
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, of, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(of)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(of, topLevelFunctionDeclaration)
        parseMethodTypeVar(of)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(of, of, false, MemberKind.TopLevelMethod)
          parseFormalParameters(of, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(of, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(of)
                              parseArguments(of)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(of, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, on, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(on)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(on, topLevelFunctionDeclaration)
        parseMethodTypeVar(on)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(on, on, false, MemberKind.TopLevelMethod)
          parseFormalParameters(on, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(on, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(on)
                              parseArguments(on)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(on, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, operator, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(operator)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(operator, topLevelFunctionDeclaration)
        parseMethodTypeVar(operator)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(operator, operator, false, MemberKind.TopLevelMethod)
          parseFormalParameters(operator, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(operator, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(operator)
                              parseArguments(operator)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(operator, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, out, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(out)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(out, topLevelFunctionDeclaration)
        parseMethodTypeVar(out)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(out, out, false, MemberKind.TopLevelMethod)
          parseFormalParameters(out, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(out, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(out)
                              parseArguments(out)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(out, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, part, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(part)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(part, topLevelFunctionDeclaration)
        parseMethodTypeVar(part)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(part, part, false, MemberKind.TopLevelMethod)
          parseFormalParameters(part, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(part, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(part)
                              parseArguments(part)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(part, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, patch, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(patch)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(patch, topLevelFunctionDeclaration)
        parseMethodTypeVar(patch)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(patch, patch, false, MemberKind.TopLevelMethod)
          parseFormalParameters(patch, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(patch, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(patch)
                              parseArguments(patch)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(patch, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, required, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(required)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(required, topLevelFunctionDeclaration)
        parseMethodTypeVar(required)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(required, required, false, MemberKind.TopLevelMethod)
          parseFormalParameters(required, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(required, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(required)
                              parseArguments(required)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(required, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(rethrow)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, rethrow, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(rethrow)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
          listener: handleIdentifier(rethrow, topLevelFunctionDeclaration)
        parseMethodTypeVar(rethrow)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(rethrow, rethrow, false, MemberKind.TopLevelMethod)
          parseFormalParameters(rethrow, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
                            listener: handleIdentifier(rethrow, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(rethrow)
                            parseArguments(rethrow)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(rethrow, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(return)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, return, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(return)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return)
          listener: handleIdentifier(return, topLevelFunctionDeclaration)
        parseMethodTypeVar(return)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(return, return, false, MemberKind.TopLevelMethod)
          parseFormalParameters(return, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                          listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
                        parsePrimary(return, expression)
                          parseParenthesizedExpressionOrFunctionLiteral(return)
                            parseParenthesizedExpression(return)
                              parseExpressionInParenthesis(return)
                                parseExpressionInParenthesisRest(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  ensureCloseParen(1, ()
                              listener: handleParenthesizedExpression(()
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, set, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(set)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(set, topLevelFunctionDeclaration)
        parseMethodTypeVar(set)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(set, set, false, MemberKind.TopLevelMethod)
          parseFormalParameters(set, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(set, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(set)
                              parseArguments(set)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(set, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, show, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(show)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(show, topLevelFunctionDeclaration)
        parseMethodTypeVar(show)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(show, show, false, MemberKind.TopLevelMethod)
          parseFormalParameters(show, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(show, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(show)
                              parseArguments(show)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(show, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, source, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(source)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(source, topLevelFunctionDeclaration)
        parseMethodTypeVar(source)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(source, source, false, MemberKind.TopLevelMethod)
          parseFormalParameters(source, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(source, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(source)
                              parseArguments(source)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(source, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, static, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(static)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(static, topLevelFunctionDeclaration)
        parseMethodTypeVar(static)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(static, static, false, MemberKind.TopLevelMethod)
          parseFormalParameters(static, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(static, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(static)
                              parseArguments(static)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(static, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(super)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, super, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(super)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super)
          listener: handleIdentifier(super, topLevelFunctionDeclaration)
        parseMethodTypeVar(super)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(super, super, false, MemberKind.TopLevelMethod)
          parseFormalParameters(super, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseSuperExpression(return, expression)
                          listener: handleSuperExpression(super, expression)
                          listener: handleNoTypeArguments(()
                          parseArguments(super)
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          isNextIdentifier(()
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              listener: endArguments(1, (, ))
                          listener: handleSend(super, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(switch)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, switch, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(switch)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch)
          listener: handleIdentifier(switch, topLevelFunctionDeclaration)
        parseMethodTypeVar(switch)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(switch, switch, false, MemberKind.TopLevelMethod)
          parseFormalParameters(switch, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(switch)
                          parseArgumentsOpt()
                            listener: handleNoArguments(switch)
                          listener: handleSend(, switch)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, switch)
          parseStatement(;)
            parseStatementX(;)
              parseSwitchStatement(;)
                listener: beginSwitchStatement(switch)
                ensureParenthesizedCondition(switch)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(-)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(-)
                                listener: handleSend(x, -)
                        listener: beginBinaryExpression(-)
                        parsePrecedenceExpression(-, 14, true)
                          parseUnaryExpression(-, true)
                            parsePrimary(-, expression)
                              parseLiteralInt(-)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(-)
                    ensureCloseParen(1, ()
                  listener: handleParenthesizedCondition(()
                parseSwitchBlock())
                  ensureBlock(), null, switch statement)
                    reportRecoverableError(), Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}])
                      listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}], ), ))
                    insertBlock())
                      rewriter()
                      rewriter()
                  listener: beginSwitchBlock({)
                  notEofOrValue(}, })
                  listener: endSwitchBlock(0, {, })
                listener: endSwitchStatement(switch, })
          notEofOrValue(}, +)
          parseStatement(})
            parseStatementX(})
              parseExpressionStatementOrDeclaration(}, false)
                parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                  looksLikeLocalFunction(+)
                  parseExpressionStatement(})
                    parseExpression(})
                      parsePrecedenceExpression(}, 1, true)
                        parseUnaryExpression(}, true)
                          rewriteAndRecover(}, UnsupportedPrefixPlus, )
                            reportRecoverableError(+, UnsupportedPrefixPlus)
                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                            rewriter()
                          parsePrimary(}, expression)
                            parseSendOrFunctionLiteral(}, expression)
                              parseSend(}, expression)
                                isNextIdentifier(})
                                ensureIdentifier(}, expression)
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt()
                                  listener: handleNoArguments(+)
                                listener: handleSend(, +)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, sync, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(sync)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(sync, topLevelFunctionDeclaration)
        parseMethodTypeVar(sync)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(sync, sync, false, MemberKind.TopLevelMethod)
          parseFormalParameters(sync, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(sync, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(sync)
                              parseArguments(sync)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(sync, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, this, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(this)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this)
          listener: handleIdentifier(this, topLevelFunctionDeclaration)
        parseMethodTypeVar(this)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(this, this, false, MemberKind.TopLevelMethod)
          parseFormalParameters(this, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseThisExpression(return, expression)
                          listener: handleThisExpression(this, expression)
                          listener: handleNoTypeArguments(()
                          parseArguments(this)
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          isNextIdentifier(()
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              listener: endArguments(1, (, ))
                          listener: handleSend(this, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(throw)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, throw, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(throw)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw)
          listener: handleIdentifier(throw, topLevelFunctionDeclaration)
        parseMethodTypeVar(throw)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(throw, throw, false, MemberKind.TopLevelMethod)
          parseFormalParameters(throw, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parseThrowExpression(return, true)
                    parseExpression(throw)
                      parsePrecedenceExpression(throw, 1, true)
                        parseUnaryExpression(throw, true)
                          parsePrimary(throw, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(throw)
                              parseParenthesizedExpression(throw)
                                parseExpressionInParenthesis(throw)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    listener: handleThrowExpression(throw, ;)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(true)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, true, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(true)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true)
          listener: handleIdentifier(true, topLevelFunctionDeclaration)
        parseMethodTypeVar(true)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(true, true, false, MemberKind.TopLevelMethod)
          parseFormalParameters(true, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseLiteralBool(return)
                          listener: handleLiteralBool(true)
                    parseArgumentOrIndexStar(true, Instance of 'NoTypeParamOrArg', false)
                      listener: handleNoTypeArguments(()
                      parseArguments(true)
                        parseArgumentsRest(()
                          listener: beginArguments(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      isNextIdentifier(()
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          listener: endArguments(1, (, ))
                      listener: handleSend((, ))
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(try)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, try, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(try)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try)
          listener: handleIdentifier(try, topLevelFunctionDeclaration)
        parseMethodTypeVar(try)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(try, try, false, MemberKind.TopLevelMethod)
          parseFormalParameters(try, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., Try inserting an identifier before 'try'., {lexeme: try}], try, try)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(try)
                          parseArgumentsOpt()
                            listener: handleNoArguments(try)
                          listener: handleSend(, try)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, try)
          parseStatement(;)
            parseStatementX(;)
              parseTryStatement(;)
                listener: beginTryStatement(try)
                parseBlock(try, BlockKind(try statement))
                  ensureBlock(try, null, try statement)
                    reportRecoverableError(try, Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}])
                      listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}], try, try)
                    insertBlock(try)
                      rewriter()
                      rewriter()
                  listener: beginBlock({, BlockKind(try statement))
                  notEofOrValue(}, })
                  listener: endBlock(0, {, }, BlockKind(try statement))
                reportRecoverableError(try, OnlyTry)
                  listener: handleRecoverableError(OnlyTry, try, try)
                listener: endTryStatement(0, try, null)
          notEofOrValue(}, ()
          parseStatement(})
            parseStatementX(})
              parseExpressionStatementOrDeclaration(}, false)
                parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(})
                    parseExpression(})
                      parsePrecedenceExpression(}, 1, true)
                        parseUnaryExpression(}, true)
                          parsePrimary(}, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(})
                              parseParenthesizedExpression(})
                                parseExpressionInParenthesis(})
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, typedef, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(typedef)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(typedef, topLevelFunctionDeclaration)
        parseMethodTypeVar(typedef)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(typedef, typedef, false, MemberKind.TopLevelMethod)
          parseFormalParameters(typedef, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(typedef, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(typedef)
                              parseArguments(typedef)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(typedef, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(var)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, var, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(var)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var)
          listener: handleIdentifier(var, topLevelFunctionDeclaration)
        parseMethodTypeVar(var)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(var, var, false, MemberKind.TopLevelMethod)
          parseFormalParameters(var, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., Try inserting an identifier before 'var'., {lexeme: var}], var, var)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(var)
                          parseArgumentsOpt()
                            listener: handleNoArguments(var)
                          listener: handleSend(, var)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, var)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false)
                looksLikeLocalFunction(()
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
                listener: handleNoType(var)
                listener: beginVariablesDeclaration((, null, var)
                parseVariablesDeclarationRest(var, true)
                  parseOptionallyInitializedIdentifier(var)
                    ensureIdentifier(var, localVariableDeclaration)
                      reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                      rewriter()
                      listener: handleIdentifier(, localVariableDeclaration)
                    listener: beginInitializedIdentifier()
                    parseVariableInitializerOpt()
                      listener: handleNoVariableInitializer()
                    listener: endInitializedIdentifier()
                  ensureSemicolon()
                    reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
                    rewriter()
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, x)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(x)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(x, expression)
                              listener: handleNoTypeArguments(-)
                              parseArgumentsOpt(x)
                                listener: handleNoArguments(-)
                              listener: handleSend(x, -)
                      listener: beginBinaryExpression(-)
                      parsePrecedenceExpression(-, 14, true)
                        parseUnaryExpression(-, true)
                          parsePrimary(-, expression)
                            parseLiteralInt(-)
                              listener: handleLiteralInt(1)
                      listener: endBinaryExpression(-)
                  ensureSemicolon(1)
                    reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, ))
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction())
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments())
                              parseArgumentsOpt()
                                listener: handleNoArguments())
                              listener: handleSend(, ))
                    ensureSemicolon()
                      reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                      rewriter()
                    listener: handleExpressionStatement(;)
          reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
          notEofOrValue(}, +)
          parseStatement())
            parseStatementX())
              parseExpressionStatementOrDeclaration(), false)
                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                  looksLikeLocalFunction(+)
                  parseExpressionStatement())
                    parseExpression())
                      parsePrecedenceExpression(), 1, true)
                        parseUnaryExpression(), true)
                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                            reportRecoverableError(+, UnsupportedPrefixPlus)
                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                            rewriter()
                          parsePrimary(), expression)
                            parseSendOrFunctionLiteral(), expression)
                              parseSend(), expression)
                                isNextIdentifier())
                                ensureIdentifier(), expression)
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt()
                                  listener: handleNoArguments(+)
                                listener: handleSend(, +)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(void)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, void, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(void)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void)
          listener: handleIdentifier(void, topLevelFunctionDeclaration)
        parseMethodTypeVar(void)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(void, void, false, MemberKind.TopLevelMethod)
          parseFormalParameters(void, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          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)
                              reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
                                listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., Try inserting an identifier before 'void'., {lexeme: void}], void, void)
                              rewriter()
                              listener: handleIdentifier(, expression)
                            listener: handleNoTypeArguments(void)
                            parseArgumentsOpt()
                              listener: handleNoArguments(void)
                            listener: handleSend(, void)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, void)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  listener: beginMetadataStar(void)
                  listener: endMetadataStar(0)
                  listener: handleVoidKeyword(void)
                  listener: beginVariablesDeclaration((, null, null)
                  parseVariablesDeclarationRest(void, true)
                    parseOptionallyInitializedIdentifier(void)
                      ensureIdentifier(void, localVariableDeclaration)
                        reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                        rewriter()
                        listener: handleIdentifier(, localVariableDeclaration)
                      listener: beginInitializedIdentifier()
                      parseVariableInitializerOpt()
                        listener: handleNoVariableInitializer()
                      listener: endInitializedIdentifier()
                    ensureSemicolon()
                      reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
                      rewriter()
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, x)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(x)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(x, expression)
                              listener: handleNoTypeArguments(-)
                              parseArgumentsOpt(x)
                                listener: handleNoArguments(-)
                              listener: handleSend(x, -)
                      listener: beginBinaryExpression(-)
                      parsePrecedenceExpression(-, 14, true)
                        parseUnaryExpression(-, true)
                          parsePrimary(-, expression)
                            parseLiteralInt(-)
                              listener: handleLiteralInt(1)
                      listener: endBinaryExpression(-)
                  ensureSemicolon(1)
                    reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, ))
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction())
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments())
                              parseArgumentsOpt()
                                listener: handleNoArguments())
                              listener: handleSend(, ))
                    ensureSemicolon()
                      reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                      rewriter()
                    listener: handleExpressionStatement(;)
          reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
          notEofOrValue(}, +)
          parseStatement())
            parseStatementX())
              parseExpressionStatementOrDeclaration(), false)
                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                  looksLikeLocalFunction(+)
                  parseExpressionStatement())
                    parseExpression())
                      parsePrecedenceExpression(), 1, true)
                        parseUnaryExpression(), true)
                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                            reportRecoverableError(+, UnsupportedPrefixPlus)
                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                            rewriter()
                          parsePrimary(), expression)
                            parseSendOrFunctionLiteral(), expression)
                              parseSend(), expression)
                                isNextIdentifier())
                                ensureIdentifier(), expression)
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt()
                                  listener: handleNoArguments(+)
                                listener: handleSend(, +)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(while)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, while, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(while)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while)
          listener: handleIdentifier(while, topLevelFunctionDeclaration)
        parseMethodTypeVar(while)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(while, while, false, MemberKind.TopLevelMethod)
          parseFormalParameters(while, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., Try inserting an identifier before 'while'., {lexeme: while}], while, while)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(while)
                          parseArgumentsOpt()
                            listener: handleNoArguments(while)
                          listener: handleSend(, while)
                ensureSemicolon()
                  reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, while)
          parseStatement(;)
            parseStatementX(;)
              parseWhileStatement(;)
                listener: beginWhileStatement(while)
                ensureParenthesizedCondition(while)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(-)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(-)
                                listener: handleSend(x, -)
                        listener: beginBinaryExpression(-)
                        parsePrecedenceExpression(-, 14, true)
                          parseUnaryExpression(-, true)
                            parsePrimary(-, expression)
                              parseLiteralInt(-)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(-)
                    ensureCloseParen(1, ()
                  listener: handleParenthesizedCondition(()
                listener: beginWhileStatementBody(+)
                parseStatement())
                  parseStatementX())
                    parseExpressionStatementOrDeclaration(), false)
                      parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                        looksLikeLocalFunction(+)
                        parseExpressionStatement())
                          parseExpression())
                            parsePrecedenceExpression(), 1, true)
                              parseUnaryExpression(), true)
                                rewriteAndRecover(), UnsupportedPrefixPlus, )
                                  reportRecoverableError(+, UnsupportedPrefixPlus)
                                    listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                  rewriter()
                                parsePrimary(), expression)
                                  parseSendOrFunctionLiteral(), expression)
                                    parseSend(), expression)
                                      isNextIdentifier())
                                      ensureIdentifier(), expression)
                                        listener: handleIdentifier(, expression)
                                      listener: handleNoTypeArguments(+)
                                      parseArgumentsOpt()
                                        listener: handleNoArguments(+)
                                      listener: handleSend(, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: handleExpressionStatement(;)
                listener: endWhileStatementBody(})
                listener: endWhileStatement(while, })
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(with)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, with, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(with)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
          listener: handleIdentifier(with, topLevelFunctionDeclaration)
        parseMethodTypeVar(with)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(with, with, false, MemberKind.TopLevelMethod)
          parseFormalParameters(with, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          isNextIdentifier(return)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
                            listener: handleIdentifier(with, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(with)
                            parseArguments(with)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            isNextIdentifier(()
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(with, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, yield, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(yield)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(yield, topLevelFunctionDeclaration)
        parseMethodTypeVar(yield)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(yield, yield, false, MemberKind.TopLevelMethod)
          parseFormalParameters(yield, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            isNextIdentifier(return)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(yield, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(yield)
                              parseArguments(yield)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              isNextIdentifier(()
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(yield, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(int)
  listener: endCompilationUnit(69, )