parseUnit(main)
  skipErrorTokens(main)
  listener: beginCompilationUnit(main)
  syntheticPreviousToken(main)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(main)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(main)
      isReservedKeyword(()
      parseTopLevelMethod(, null, , Instance of 'NoType', null, main, false)
        listener: beginTopLevelMethod(, null)
        listener: handleNoType()
        ensureIdentifierPotentiallyRecovered(, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(main, topLevelFunctionDeclaration)
        parseMethodTypeVar(main)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(main, main, false, MemberKind.TopLevelMethod)
          parseFormalParameters(main, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, dynamic)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, false)
                parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                  looksLikeLocalFunction(foo)
                  listener: beginMetadataStar(dynamic)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(dynamic, typeReference)
                  listener: handleNoTypeArguments(foo)
                  listener: handleType(dynamic, null)
                  listener: beginVariablesDeclaration(foo, null, null)
                  parseVariablesDeclarationRest(dynamic, true)
                    parseOptionallyInitializedIdentifier(dynamic)
                      ensureIdentifier(dynamic, localVariableDeclaration)
                        listener: handleIdentifier(foo, localVariableDeclaration)
                      listener: beginInitializedIdentifier(foo)
                      parseVariableInitializerOpt(foo)
                        listener: beginVariableInitializer(=)
                        parseExpression(=)
                          parsePrecedenceExpression(=, 1, true)
                            parseUnaryExpression(=, true)
                              parsePrimary(=, expression)
                                parseNewExpression(=)
                                  listener: beginNewExpression(new)
                                  parseConstructorReference(new, null)
                                    ensureIdentifier(new, constructorReference)
                                      listener: handleIdentifier(X, constructorReference)
                                    listener: beginConstructorReference(X)
                                    parseQualifiedRestOpt(X, constructorReferenceContinuation)
                                    listener: handleNoTypeArguments(()
                                    listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                    listener: endConstructorReference(X, null, ()
                                  parseConstructorInvocationArguments(X)
                                    parseArgumentsRest(()
                                      listener: beginArguments(()
                                      listener: endArguments(0, (, ))
                                  listener: endNewExpression(new)
                        listener: endVariableInitializer(=)
                      listener: endInitializedIdentifier(foo)
                    ensureSemicolon())
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, var)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false)
                looksLikeLocalFunction(bar)
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
                listener: handleNoType(var)
                listener: beginVariablesDeclaration(bar, null, var)
                parseVariablesDeclarationRest(var, true)
                  parseOptionallyInitializedIdentifier(var)
                    ensureIdentifier(var, localVariableDeclaration)
                      listener: handleIdentifier(bar, localVariableDeclaration)
                    listener: beginInitializedIdentifier(bar)
                    parseVariableInitializerOpt(bar)
                      listener: beginVariableInitializer(=)
                      parseExpression(=)
                        parsePrecedenceExpression(=, 1, true)
                          parseUnaryExpression(=, true)
                            parsePrimary(=, expression)
                              parseSendOrFunctionLiteral(=, expression)
                                parseSend(=, expression)
                                  ensureIdentifier(=, expression)
                                    listener: handleIdentifier(foo, expression)
                                  listener: handleNoTypeArguments(.)
                                  parseArgumentsOpt(foo)
                                    listener: handleNoArguments(.)
                                  listener: handleSend(foo, .)
                          parsePrimary(., expressionContinuation)
                            inPlainSync()
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                ensureIdentifier(., expressionContinuation)
                                  inPlainSync()
                                  listener: handleIdentifier(required, expressionContinuation)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(required)
                                  listener: handleNoArguments(;)
                                listener: handleSend(required, ;)
                          listener: handleEndingBinaryExpression(.)
                      listener: endVariableInitializer(=)
                    listener: endInitializedIdentifier(bar)
                  ensureSemicolon(required)
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, required)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(required)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            inPlainSync()
                            parseSendOrFunctionLiteral(;, expression)
                              looksLikeFunctionBody(;)
                              parseSend(;, expression)
                                ensureIdentifier(;, expression)
                                  inPlainSync()
                                  listener: handleIdentifier(required, expression)
                                listener: handleNoTypeArguments(()
                                parseArgumentsOpt(required)
                                  parseArguments(required)
                                    parseArgumentsRest(()
                                      listener: beginArguments(()
                                      listener: endArguments(0, (, ))
                                listener: handleSend(required, ;)
                    ensureSemicolon())
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, bar)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(bar)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(bar, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(bar)
                                parseArguments(bar)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    listener: endArguments(0, (, ))
                              listener: handleSend(bar, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, new)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(new)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseNewExpression(;)
                              listener: beginNewExpression(new)
                              parseConstructorReference(new, null)
                                ensureIdentifier(new, constructorReference)
                                  listener: handleIdentifier(X, constructorReference)
                                listener: beginConstructorReference(X)
                                parseQualifiedRestOpt(X, constructorReferenceContinuation)
                                listener: handleNoTypeArguments(()
                                listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                listener: endConstructorReference(X, null, ()
                              parseConstructorInvocationArguments(X)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  listener: endArguments(0, (, ))
                              listener: endNewExpression(new)
                        parsePrimary(., expressionContinuation)
                          inPlainSync()
                          parseSendOrFunctionLiteral(., expressionContinuation)
                            looksLikeFunctionBody(;)
                            parseSend(., expressionContinuation)
                              ensureIdentifier(., expressionContinuation)
                                inPlainSync()
                                listener: handleIdentifier(required, expressionContinuation)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(required)
                                parseArguments(required)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    listener: endArguments(0, (, ))
                              listener: handleSend(required, ;)
                        listener: handleEndingBinaryExpression(.)
                    ensureSemicolon())
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, new)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(new)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseNewExpression(;)
                              listener: beginNewExpression(new)
                              parseConstructorReference(new, null)
                                ensureIdentifier(new, constructorReference)
                                  listener: handleIdentifier(Y, constructorReference)
                                listener: beginConstructorReference(Y)
                                parseQualifiedRestOpt(Y, constructorReferenceContinuation)
                                listener: handleNoTypeArguments(()
                                listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                listener: endConstructorReference(Y, null, ()
                              parseConstructorInvocationArguments(Y)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  listener: endArguments(0, (, ))
                              listener: endNewExpression(new)
                        parsePrimary(., expressionContinuation)
                          inPlainSync()
                          parseSendOrFunctionLiteral(., expressionContinuation)
                            parseSend(., expressionContinuation)
                              ensureIdentifier(., expressionContinuation)
                                inPlainSync()
                                listener: handleIdentifier(required, expressionContinuation)
                              listener: handleNoTypeArguments(;)
                              parseArgumentsOpt(required)
                                listener: handleNoArguments(;)
                              listener: handleSend(required, ;)
                        listener: handleEndingBinaryExpression(.)
                    ensureSemicolon(required)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(main, null, })
  listener: endTopLevelDeclaration(required)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(required)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(required)
      isReservedKeyword(()
      parseTopLevelMethod(}, null, }, Instance of 'NoType', null, required, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleNoType(})
        ensureIdentifierPotentiallyRecovered(}, 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)
              parseOptionalNamedParameters((, MemberKind.TopLevelMethod)
                listener: beginOptionalFormalParameters({)
                parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.TopLevelMethod)
                  parseMetadataStar({)
                    listener: beginMetadataStar(required)
                    listener: endMetadataStar(0)
                  listener: beginFormalParameter(required, MemberKind.TopLevelMethod, required, null, null)
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(named)
                  listener: handleType(int, null)
                  ensureIdentifier(int, formalParameterDeclaration)
                    listener: handleIdentifier(named, formalParameterDeclaration)
                  listener: handleFormalParameterWithoutValue(})
                  listener: endFormalParameter(null, null, named, null, null, FormalParameterKind.optionalNamed, MemberKind.TopLevelMethod)
                listener: endOptionalFormalParameters(1, {, })
              ensureCloseParen(}, ()
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, print)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                looksLikeLocalFunction(print)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseSendOrFunctionLiteral({, expression)
                            looksLikeFunctionBody(;)
                            parseSend({, expression)
                              ensureIdentifier({, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseLiteralString(()
                                              parseSingleLiteralString(()
                                                listener: beginLiteralString("hello")
                                                listener: endLiteralString(0, ))
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(required, null, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(X, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, X)
        parseClass(X, class, class, X)
          parseClassHeaderOpt(X, class, class)
            parseClassExtendsOpt(X)
              listener: handleNoType(X)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(X)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(X)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(X, DeclarationKind.Class, X)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, required)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, X)
              parseMetadataStar({)
                listener: beginMetadataStar(required)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, required, DeclarationKind.Class, X, false)
                listener: beginMethod(null, null, null, null, null, required)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(required, methodDeclaration)
                parseQualifiedRestOpt(required, methodDeclarationContinuation)
                parseMethodTypeVar(required)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(required, required, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(required, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, print)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                        looksLikeLocalFunction(print)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseSendOrFunctionLiteral({, expression)
                                    looksLikeFunctionBody(;)
                                    parseSend({, expression)
                                      ensureIdentifier({, expression)
                                        listener: handleIdentifier(print, expression)
                                      listener: handleNoTypeArguments(()
                                      parseArgumentsOpt(print)
                                        parseArguments(print)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            parseExpression(()
                                              parsePrecedenceExpression((, 1, true)
                                                parseUnaryExpression((, true)
                                                  parsePrimary((, expression)
                                                    parseLiteralString(()
                                                      parseSingleLiteralString(()
                                                        listener: beginLiteralString("hello")
                                                        listener: endLiteralString(0, ))
                                            listener: endArguments(1, (, ))
                                      listener: handleSend(print, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, required, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Y, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Y)
        parseClass(Y, class, class, Y)
          parseClassHeaderOpt(Y, class, class)
            parseClassExtendsOpt(Y)
              listener: handleNoType(Y)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(Y)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Y)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Y, DeclarationKind.Class, Y)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Y)
              parseMetadataStar({)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, {, Instance of 'SimpleType', required, DeclarationKind.Class, Y, false)
                listener: beginFields({)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(required)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(required, fieldDeclaration)
                parseFieldInitializerOpt(required, required, null, null, null, null, DeclarationKind.Class, Y)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(42)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, null, null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(main)
  listener: endCompilationUnit(4, )