parseUnit(abstract)
  skipErrorTokens(abstract)
  listener: beginCompilationUnit(abstract)
  syntheticPreviousToken(abstract)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(abstract)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(abstract, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(abstract)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Key, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(abstract, abstract, null, null, Key)
        parseClass(Key, abstract, class, Key)
          parseClassHeaderOpt(Key, abstract, class)
            parseClassExtendsOpt(Key)
              listener: handleNoType(Key)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(Key)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(Key)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(abstract, class, null)
          parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Key)
              parseMetadataStar({)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, a, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, a)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(a, methodDeclaration)
                parseQualifiedRestOpt(a, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(a, a, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(a)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(a)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(a, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseSendOrFunctionLiteral(=>, expression)
                              parseSend(=>, expression)
                                isNextIdentifier(=>)
                                ensureIdentifier(=>, expression)
                                  listener: handleIdentifier(runtimeType, expression)
                                listener: handleNoTypeArguments(.)
                                parseArgumentsOpt(runtimeType)
                                  listener: handleNoArguments(.)
                                listener: handleSend(runtimeType, .)
                        parsePrimary(., expressionContinuation)
                          parseSendOrFunctionLiteral(., expressionContinuation)
                            parseSend(., expressionContinuation)
                              isNextIdentifier(.)
                              ensureIdentifier(., expressionContinuation)
                                listener: handleIdentifier(hashCode, expressionContinuation)
                              listener: handleNoTypeArguments(xor)
                              parseArgumentsOpt(hashCode)
                                listener: handleNoArguments(xor)
                              listener: handleSend(hashCode, xor)
                        listener: handleEndingBinaryExpression(.)
                        rewriter()
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                parseArgumentsOpt(hashCode)
                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                        rewriter()
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                                listener: handleLiteralNull(null)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(;)
                                listener: handleSend(hashCode, ;)
                          listener: handleEndingBinaryExpression(.)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(hashCode)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, int, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, b, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, b)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(b, methodDeclaration)
                parseQualifiedRestOpt(b, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(b, b, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(b)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(b)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(b, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseSendOrFunctionLiteral(=>, expression)
                              parseSend(=>, expression)
                                isNextIdentifier(=>)
                                ensureIdentifier(=>, expression)
                                  listener: handleIdentifier(runtimeType, expression)
                                listener: handleNoTypeArguments(.)
                                parseArgumentsOpt(runtimeType)
                                  listener: handleNoArguments(.)
                                listener: handleSend(runtimeType, .)
                        parsePrimary(., expressionContinuation)
                          parseSendOrFunctionLiteral(., expressionContinuation)
                            parseSend(., expressionContinuation)
                              isNextIdentifier(.)
                              ensureIdentifier(., expressionContinuation)
                                listener: handleIdentifier(hashCode, expressionContinuation)
                              listener: handleNoTypeArguments(^)
                              parseArgumentsOpt(hashCode)
                                listener: handleNoArguments(^)
                              listener: handleSend(hashCode, ^)
                        listener: handleEndingBinaryExpression(.)
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                                listener: handleLiteralNull(null)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(;)
                                listener: handleSend(hashCode, ;)
                          listener: handleEndingBinaryExpression(.)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(hashCode)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, int, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, c, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, c)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(c, methodDeclaration)
                parseQualifiedRestOpt(c, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(c, c, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(c)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(c)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(c, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(runtimeType, expression)
                                    listener: handleNoTypeArguments(.)
                                    parseArgumentsOpt(runtimeType)
                                      listener: handleNoArguments(.)
                                    listener: handleSend(runtimeType, .)
                            parsePrimary(., expressionContinuation)
                              parseSendOrFunctionLiteral(., expressionContinuation)
                                parseSend(., expressionContinuation)
                                  isNextIdentifier(.)
                                  ensureIdentifier(., expressionContinuation)
                                    listener: handleIdentifier(hashCode, expressionContinuation)
                                  listener: handleNoTypeArguments(xor)
                                  parseArgumentsOpt(hashCode)
                                    listener: handleNoArguments(xor)
                                  listener: handleSend(hashCode, xor)
                            listener: handleEndingBinaryExpression(.)
                            rewriter()
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                    parseArgumentsOpt(hashCode)
                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                            rewriter()
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                                    listener: handleLiteralNull(null)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(hashCode, ;)
                              listener: handleEndingBinaryExpression(.)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(hashCode)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(get, int, {, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, d, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, d)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(d, methodDeclaration)
                parseQualifiedRestOpt(d, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(d, d, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(d)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(d)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(d, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(runtimeType, expression)
                                    listener: handleNoTypeArguments(.)
                                    parseArgumentsOpt(runtimeType)
                                      listener: handleNoArguments(.)
                                    listener: handleSend(runtimeType, .)
                            parsePrimary(., expressionContinuation)
                              parseSendOrFunctionLiteral(., expressionContinuation)
                                parseSend(., expressionContinuation)
                                  isNextIdentifier(.)
                                  ensureIdentifier(., expressionContinuation)
                                    listener: handleIdentifier(hashCode, expressionContinuation)
                                  listener: handleNoTypeArguments(^)
                                  parseArgumentsOpt(hashCode)
                                    listener: handleNoArguments(^)
                                  listener: handleSend(hashCode, ^)
                            listener: handleEndingBinaryExpression(.)
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                                    listener: handleLiteralNull(null)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(hashCode, ;)
                              listener: handleEndingBinaryExpression(.)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(hashCode)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(get, int, {, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, e, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, e)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(e, methodDeclaration)
                parseQualifiedRestOpt(e, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(e, e, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(e)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(e)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(e, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(1)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseSendOrFunctionLiteral(+, expression)
                                parseSend(+, expression)
                                  isNextIdentifier(+)
                                  ensureIdentifier(+, expression)
                                    listener: handleIdentifier(runtimeType, expression)
                                  listener: handleNoTypeArguments(.)
                                  parseArgumentsOpt(runtimeType)
                                    listener: handleNoArguments(.)
                                  listener: handleSend(runtimeType, .)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(xor)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(xor)
                                listener: handleSend(hashCode, xor)
                          listener: handleEndingBinaryExpression(.)
                          rewriter()
                        listener: endBinaryExpression(+)
                        rewriter()
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                parseArgumentsOpt(hashCode)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                        rewriter()
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                                listener: handleLiteralNull(null)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(+)
                                listener: handleSend(hashCode, +)
                          listener: handleEndingBinaryExpression(.)
                          listener: beginBinaryExpression(+)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                                  listener: handleLiteralInt(3)
                          listener: endBinaryExpression(+)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(3)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, int, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, f, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, f)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(f, methodDeclaration)
                parseQualifiedRestOpt(f, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(f, f, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(f)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(f)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(f, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(1)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseSendOrFunctionLiteral(+, expression)
                                parseSend(+, expression)
                                  isNextIdentifier(+)
                                  ensureIdentifier(+, expression)
                                    listener: handleIdentifier(runtimeType, expression)
                                  listener: handleNoTypeArguments(.)
                                  parseArgumentsOpt(runtimeType)
                                    listener: handleNoArguments(.)
                                  listener: handleSend(runtimeType, .)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(^)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(^)
                                listener: handleSend(hashCode, ^)
                          listener: handleEndingBinaryExpression(.)
                        listener: endBinaryExpression(+)
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseLiteralNull(^)
                                listener: handleLiteralNull(null)
                          parsePrimary(., expressionContinuation)
                            parseSendOrFunctionLiteral(., expressionContinuation)
                              parseSend(., expressionContinuation)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  listener: handleIdentifier(hashCode, expressionContinuation)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt(hashCode)
                                  listener: handleNoArguments(+)
                                listener: handleSend(hashCode, +)
                          listener: handleEndingBinaryExpression(.)
                          listener: beginBinaryExpression(+)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                                  listener: handleLiteralInt(3)
                          listener: endBinaryExpression(+)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(3)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, int, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, g, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, g)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(g, methodDeclaration)
                parseQualifiedRestOpt(g, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(g, g, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(g)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(g)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(g, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(1)
                            listener: beginBinaryExpression(+)
                            parsePrecedenceExpression(+, 14, true)
                              parseUnaryExpression(+, true)
                                parsePrimary(+, expression)
                                  parseSendOrFunctionLiteral(+, expression)
                                    parseSend(+, expression)
                                      isNextIdentifier(+)
                                      ensureIdentifier(+, expression)
                                        listener: handleIdentifier(runtimeType, expression)
                                      listener: handleNoTypeArguments(.)
                                      parseArgumentsOpt(runtimeType)
                                        listener: handleNoArguments(.)
                                      listener: handleSend(runtimeType, .)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(xor)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(xor)
                                    listener: handleSend(hashCode, xor)
                              listener: handleEndingBinaryExpression(.)
                              rewriter()
                            listener: endBinaryExpression(+)
                            rewriter()
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                    parseArgumentsOpt(hashCode)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                            rewriter()
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                                    listener: handleLiteralNull(null)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(+)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(+)
                                    listener: handleSend(hashCode, +)
                              listener: handleEndingBinaryExpression(.)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(3)
                              listener: endBinaryExpression(+)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(3)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(get, int, {, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, h, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, get, h)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(h, methodDeclaration)
                parseQualifiedRestOpt(h, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(h, h, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(h)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(h)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(h, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(1)
                            listener: beginBinaryExpression(+)
                            parsePrecedenceExpression(+, 14, true)
                              parseUnaryExpression(+, true)
                                parsePrimary(+, expression)
                                  parseSendOrFunctionLiteral(+, expression)
                                    parseSend(+, expression)
                                      isNextIdentifier(+)
                                      ensureIdentifier(+, expression)
                                        listener: handleIdentifier(runtimeType, expression)
                                      listener: handleNoTypeArguments(.)
                                      parseArgumentsOpt(runtimeType)
                                        listener: handleNoArguments(.)
                                      listener: handleSend(runtimeType, .)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(^)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(^)
                                    listener: handleSend(hashCode, ^)
                              listener: handleEndingBinaryExpression(.)
                            listener: endBinaryExpression(+)
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseLiteralNull(^)
                                    listener: handleLiteralNull(null)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(hashCode, expressionContinuation)
                                    listener: handleNoTypeArguments(+)
                                    parseArgumentsOpt(hashCode)
                                      listener: handleNoArguments(+)
                                    listener: handleSend(hashCode, +)
                              listener: handleEndingBinaryExpression(.)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(3)
                              listener: endBinaryExpression(+)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(3)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(get, int, {, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, i, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, i)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(i)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(i, methodDeclaration)
                parseQualifiedRestOpt(i, methodDeclarationContinuation)
                parseMethodTypeVar(i)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(i, i, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(i, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseSendOrFunctionLiteral(=>, expression)
                              parseSend(=>, expression)
                                isNextIdentifier(=>)
                                ensureIdentifier(=>, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(xor)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(xor)
                                listener: handleSend(x, xor)
                        rewriter()
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                  parseArgumentsOpt(y)
                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                        rewriter()
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                    listener: handleIdentifier(y, expression)
                                  listener: handleNoTypeArguments(;)
                                  parseArgumentsOpt(y)
                                    listener: handleNoArguments(;)
                                  listener: handleSend(y, ;)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(y)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, int, (, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, j, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, j)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(j)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(j, methodDeclaration)
                parseQualifiedRestOpt(j, methodDeclarationContinuation)
                parseMethodTypeVar(j)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(j, j, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(j, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    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(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                    listener: handleIdentifier(y, expression)
                                  listener: handleNoTypeArguments(;)
                                  parseArgumentsOpt(y)
                                    listener: handleNoArguments(;)
                                  listener: handleSend(y, ;)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(y)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, int, (, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, k, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, k)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(k)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(k, methodDeclaration)
                parseQualifiedRestOpt(k, methodDeclarationContinuation)
                parseMethodTypeVar(k)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(k, k, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(k, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(x, expression)
                                    listener: handleNoTypeArguments(xor)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(xor)
                                    listener: handleSend(x, xor)
                            rewriter()
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                      parseArgumentsOpt(y)
                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                            rewriter()
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                        listener: handleIdentifier(y, expression)
                                      listener: handleNoTypeArguments(;)
                                      parseArgumentsOpt(y)
                                        listener: handleNoArguments(;)
                                      listener: handleSend(y, ;)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(y)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, l, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, l)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(l)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(l, methodDeclaration)
                parseQualifiedRestOpt(l, methodDeclarationContinuation)
                parseMethodTypeVar(l)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(l, l, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(l, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(x, expression)
                                    listener: handleNoTypeArguments(^)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(^)
                                    listener: handleSend(x, ^)
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                        listener: handleIdentifier(y, expression)
                                      listener: handleNoTypeArguments(;)
                                      parseArgumentsOpt(y)
                                        listener: handleNoArguments(;)
                                      listener: handleSend(y, ;)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(y)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, m, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, m)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(m)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(m, methodDeclaration)
                parseQualifiedRestOpt(m, methodDeclarationContinuation)
                parseMethodTypeVar(m)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(m, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, int)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                        looksLikeLocalFunction(z)
                        listener: beginMetadataStar(int)
                        listener: endMetadataStar(0)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(z)
                        listener: handleType(int, null)
                        listener: beginVariablesDeclaration(z, null, null)
                        parseVariablesDeclarationRest(int, true)
                          parseOptionallyInitializedIdentifier(int)
                            ensureIdentifier(int, localVariableDeclaration)
                              listener: handleIdentifier(z, localVariableDeclaration)
                            listener: beginInitializedIdentifier(z)
                            parseVariableInitializerOpt(z)
                              listener: beginVariableInitializer(=)
                              parseExpression(=)
                                parsePrecedenceExpression(=, 1, true)
                                  parseUnaryExpression(=, true)
                                    parsePrimary(=, expression)
                                      parseSendOrFunctionLiteral(=, expression)
                                        parseSend(=, expression)
                                          isNextIdentifier(=)
                                          ensureIdentifier(=, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(xor)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(xor)
                                          listener: handleSend(x, xor)
                                  rewriter()
                                  parsePrecedenceExpression(^, 11, true)
                                    parseUnaryExpression(^, true)
                                      parsePrimary(^, expression)
                                        parseSendOrFunctionLiteral(^, expression)
                                          parseSend(^, expression)
                                            isNextIdentifier(^)
                                            ensureIdentifier(^, expression)
                                            parseArgumentsOpt(y)
                                  reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                    listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                  rewriter()
                                  listener: beginBinaryExpression(^)
                                  parsePrecedenceExpression(^, 11, true)
                                    parseUnaryExpression(^, true)
                                      parsePrimary(^, expression)
                                        parseSendOrFunctionLiteral(^, expression)
                                          parseSend(^, expression)
                                            isNextIdentifier(^)
                                            ensureIdentifier(^, expression)
                                              listener: handleIdentifier(y, expression)
                                            listener: handleNoTypeArguments(;)
                                            parseArgumentsOpt(y)
                                              listener: handleNoArguments(;)
                                            listener: handleSend(y, ;)
                                  listener: endBinaryExpression(^)
                              listener: endVariableInitializer(=)
                            listener: endInitializedIdentifier(z)
                          ensureSemicolon(y)
                          listener: endVariablesDeclaration(1, ;)
                  notEofOrValue(}, return)
                  parseStatement(;)
                    parseStatementX(;)
                      parseReturnStatement(;)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(z, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(z)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(z, ;)
                        ensureSemicolon(z)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(2, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, n, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, n)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(n)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(n, methodDeclaration)
                parseQualifiedRestOpt(n, methodDeclarationContinuation)
                parseMethodTypeVar(n)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(n, n, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(n, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, int)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                        looksLikeLocalFunction(z)
                        listener: beginMetadataStar(int)
                        listener: endMetadataStar(0)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(z)
                        listener: handleType(int, null)
                        listener: beginVariablesDeclaration(z, null, null)
                        parseVariablesDeclarationRest(int, true)
                          parseOptionallyInitializedIdentifier(int)
                            ensureIdentifier(int, localVariableDeclaration)
                              listener: handleIdentifier(z, localVariableDeclaration)
                            listener: beginInitializedIdentifier(z)
                            parseVariableInitializerOpt(z)
                              listener: beginVariableInitializer(=)
                              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(^, 11, true)
                                    parseUnaryExpression(^, true)
                                      parsePrimary(^, expression)
                                        parseSendOrFunctionLiteral(^, expression)
                                          parseSend(^, expression)
                                            isNextIdentifier(^)
                                            ensureIdentifier(^, expression)
                                              listener: handleIdentifier(y, expression)
                                            listener: handleNoTypeArguments(;)
                                            parseArgumentsOpt(y)
                                              listener: handleNoArguments(;)
                                            listener: handleSend(y, ;)
                                  listener: endBinaryExpression(^)
                              listener: endVariableInitializer(=)
                            listener: endInitializedIdentifier(z)
                          ensureSemicolon(y)
                          listener: endVariablesDeclaration(1, ;)
                  notEofOrValue(}, return)
                  parseStatement(;)
                    parseStatementX(;)
                      parseReturnStatement(;)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(z, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(z)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(z, ;)
                        ensureSemicolon(z)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(2, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, o, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, o)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(o)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(o, methodDeclaration)
                parseQualifiedRestOpt(o, methodDeclarationContinuation)
                parseMethodTypeVar(o)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(o, o, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(o, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(1)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseSendOrFunctionLiteral(+, expression)
                                parseSend(+, expression)
                                  isNextIdentifier(+)
                                  ensureIdentifier(+, expression)
                                    listener: handleIdentifier(x, expression)
                                  listener: handleNoTypeArguments(xor)
                                  parseArgumentsOpt(x)
                                    listener: handleNoArguments(xor)
                                  listener: handleSend(x, xor)
                          rewriter()
                        listener: endBinaryExpression(+)
                        rewriter()
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                  parseArgumentsOpt(y)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                        rewriter()
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                    listener: handleIdentifier(y, expression)
                                  listener: handleNoTypeArguments(+)
                                  parseArgumentsOpt(y)
                                    listener: handleNoArguments(+)
                                  listener: handleSend(y, +)
                          listener: beginBinaryExpression(+)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                                  listener: handleLiteralInt(3)
                          listener: endBinaryExpression(+)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(3)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, int, (, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, p, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, p)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(p)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(p, methodDeclaration)
                parseQualifiedRestOpt(p, methodDeclarationContinuation)
                parseMethodTypeVar(p)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(p, p, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(p, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(1)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, 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: endBinaryExpression(+)
                        listener: beginBinaryExpression(^)
                        parsePrecedenceExpression(^, 11, true)
                          parseUnaryExpression(^, true)
                            parsePrimary(^, expression)
                              parseSendOrFunctionLiteral(^, expression)
                                parseSend(^, expression)
                                  isNextIdentifier(^)
                                  ensureIdentifier(^, expression)
                                    listener: handleIdentifier(y, expression)
                                  listener: handleNoTypeArguments(+)
                                  parseArgumentsOpt(y)
                                    listener: handleNoArguments(+)
                                  listener: handleSend(y, +)
                          listener: beginBinaryExpression(+)
                          parsePrecedenceExpression(+, 14, true)
                            parseUnaryExpression(+, true)
                              parsePrimary(+, expression)
                                parseLiteralInt(+)
                                  listener: handleLiteralInt(3)
                          listener: endBinaryExpression(+)
                        listener: endBinaryExpression(^)
                    ensureSemicolon(3)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, int, (, null, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, q, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, q)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(q)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(q, methodDeclaration)
                parseQualifiedRestOpt(q, methodDeclarationContinuation)
                parseMethodTypeVar(q)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(q, q, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(q, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(1)
                            listener: beginBinaryExpression(+)
                            parsePrecedenceExpression(+, 14, true)
                              parseUnaryExpression(+, true)
                                parsePrimary(+, expression)
                                  parseSendOrFunctionLiteral(+, expression)
                                    parseSend(+, expression)
                                      isNextIdentifier(+)
                                      ensureIdentifier(+, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(xor)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(xor)
                                      listener: handleSend(x, xor)
                              rewriter()
                            listener: endBinaryExpression(+)
                            rewriter()
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                      parseArgumentsOpt(y)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                            rewriter()
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                        listener: handleIdentifier(y, expression)
                                      listener: handleNoTypeArguments(+)
                                      parseArgumentsOpt(y)
                                        listener: handleNoArguments(+)
                                      listener: handleSend(y, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(3)
                              listener: endBinaryExpression(+)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(3)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, r, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, r)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(r)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(r, methodDeclaration)
                parseQualifiedRestOpt(r, methodDeclarationContinuation)
                parseMethodTypeVar(r)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(r, r, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(r, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(1)
                            listener: beginBinaryExpression(+)
                            parsePrecedenceExpression(+, 14, 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: endBinaryExpression(+)
                            listener: beginBinaryExpression(^)
                            parsePrecedenceExpression(^, 11, true)
                              parseUnaryExpression(^, true)
                                parsePrimary(^, expression)
                                  parseSendOrFunctionLiteral(^, expression)
                                    parseSend(^, expression)
                                      isNextIdentifier(^)
                                      ensureIdentifier(^, expression)
                                        listener: handleIdentifier(y, expression)
                                      listener: handleNoTypeArguments(+)
                                      parseArgumentsOpt(y)
                                        listener: handleNoArguments(+)
                                      listener: handleSend(y, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(3)
                              listener: endBinaryExpression(+)
                            listener: endBinaryExpression(^)
                        ensureSemicolon(3)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, s)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(s)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, s, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, s)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(s, methodDeclaration)
                parseQualifiedRestOpt(s, methodDeclarationContinuation)
                parseMethodTypeVar(s)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(s, s, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(s, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, s)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                        looksLikeLocalFunction(s)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseSendOrFunctionLiteral({, expression)
                                    looksLikeFunctionBody(;)
                                    parseSend({, expression)
                                      isNextIdentifier({)
                                      ensureIdentifier({, expression)
                                        listener: handleIdentifier(s, expression)
                                      listener: handleNoTypeArguments(()
                                      parseArgumentsOpt(s)
                                        parseArguments(s)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            parseExpression(()
                                              parsePrecedenceExpression((, 1, true)
                                                parseUnaryExpression((, true)
                                                  parsePrimary((, expression)
                                                    parseSendOrFunctionLiteral((, expression)
                                                      parseSend((, expression)
                                                        isNextIdentifier(()
                                                        ensureIdentifier((, expression)
                                                          listener: handleIdentifier(x, expression)
                                                        listener: handleNoTypeArguments(xor)
                                                        parseArgumentsOpt(x)
                                                          listener: handleNoArguments(xor)
                                                        listener: handleSend(x, xor)
                                                rewriter()
                                                parsePrecedenceExpression(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                          parseArgumentsOpt(y)
                                                reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                rewriter()
                                                listener: beginBinaryExpression(^)
                                                parsePrecedenceExpression(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                            listener: handleIdentifier(y, expression)
                                                          listener: handleNoTypeArguments(,)
                                                          parseArgumentsOpt(y)
                                                            listener: handleNoArguments(,)
                                                          listener: handleSend(y, ,)
                                                listener: endBinaryExpression(^)
                                            parseExpression(,)
                                              parsePrecedenceExpression(,, 1, true)
                                                parseUnaryExpression(,, true)
                                                  parsePrimary(,, expression)
                                                    parseSendOrFunctionLiteral(,, expression)
                                                      parseSend(,, expression)
                                                        isNextIdentifier(,)
                                                        ensureIdentifier(,, expression)
                                                          listener: handleIdentifier(x, expression)
                                                        listener: handleNoTypeArguments(xor)
                                                        parseArgumentsOpt(x)
                                                          listener: handleNoArguments(xor)
                                                        listener: handleSend(x, xor)
                                                rewriter()
                                                parsePrecedenceExpression(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                          parseArgumentsOpt(y)
                                                reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                rewriter()
                                                listener: beginBinaryExpression(^)
                                                parsePrecedenceExpression(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                            listener: handleIdentifier(y, expression)
                                                          listener: handleNoTypeArguments())
                                                          parseArgumentsOpt(y)
                                                            listener: handleNoArguments())
                                                          listener: handleSend(y, ))
                                                listener: endBinaryExpression(^)
                                            listener: endArguments(2, (, ))
                                      listener: handleSend(s, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, s)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                        looksLikeLocalFunction(s)
                        parseExpressionStatement(;)
                          parseExpression(;)
                            parsePrecedenceExpression(;, 1, true)
                              parseUnaryExpression(;, true)
                                parsePrimary(;, expression)
                                  parseSendOrFunctionLiteral(;, expression)
                                    looksLikeFunctionBody(;)
                                    parseSend(;, expression)
                                      isNextIdentifier(;)
                                      ensureIdentifier(;, expression)
                                        listener: handleIdentifier(s, expression)
                                      listener: handleNoTypeArguments(()
                                      parseArgumentsOpt(s)
                                        parseArguments(s)
                                          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(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                            listener: handleIdentifier(y, expression)
                                                          listener: handleNoTypeArguments(,)
                                                          parseArgumentsOpt(y)
                                                            listener: handleNoArguments(,)
                                                          listener: handleSend(y, ,)
                                                listener: endBinaryExpression(^)
                                            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(^, 11, true)
                                                  parseUnaryExpression(^, true)
                                                    parsePrimary(^, expression)
                                                      parseSendOrFunctionLiteral(^, expression)
                                                        parseSend(^, expression)
                                                          isNextIdentifier(^)
                                                          ensureIdentifier(^, expression)
                                                            listener: handleIdentifier(y, expression)
                                                          listener: handleNoTypeArguments())
                                                          parseArgumentsOpt(y)
                                                            listener: handleNoArguments())
                                                          listener: handleSend(y, ))
                                                listener: endBinaryExpression(^)
                                            listener: endArguments(2, (, ))
                                      listener: handleSend(s, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(2, {, })
                listener: endClassMethod(null, s, (, null, })
              listener: endMember()
            notEofOrValue(}, Key)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(Key)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, Key)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(Key, methodDeclaration)
                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
                parseMethodTypeVar(Key)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(foo)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    isNextIdentifier(:)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(foo, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(foo)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(foo, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(xor)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(xor)
                                      listener: handleSend(x, xor)
                              rewriter()
                              parsePrecedenceExpression(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                        parseArgumentsOpt(y)
                              reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                              rewriter()
                              listener: beginBinaryExpression(^)
                              parsePrecedenceExpression(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                          listener: handleIdentifier(y, expression)
                                        listener: handleNoTypeArguments(,)
                                        parseArgumentsOpt(y)
                                          listener: handleNoArguments(,)
                                        listener: handleSend(y, ,)
                              listener: endBinaryExpression(^)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(bar)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(bar, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bar)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bar, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(xor)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(xor)
                                      listener: handleSend(x, xor)
                              rewriter()
                              parsePrecedenceExpression(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                        parseArgumentsOpt(y)
                              reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                              rewriter()
                              listener: beginBinaryExpression(^)
                              parsePrecedenceExpression(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                          listener: handleIdentifier(y, expression)
                                        listener: handleNoTypeArguments({)
                                        parseArgumentsOpt(y)
                                          listener: handleNoArguments({)
                                        listener: handleSend(y, {)
                              listener: endBinaryExpression(^)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(2, :, {)
                parseAsyncModifierOpt(y)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(y, 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)
                                      isNextIdentifier({)
                                      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 )
                                                        parseExpression(${)
                                                          parsePrecedenceExpression(${, 1, true)
                                                            parseUnaryExpression(${, true)
                                                              parsePrimary(${, expression)
                                                                parseSendOrFunctionLiteral(${, expression)
                                                                  parseSend(${, expression)
                                                                    isNextIdentifier(${)
                                                                    ensureIdentifier(${, expression)
                                                                      listener: handleIdentifier(x, expression)
                                                                    listener: handleNoTypeArguments(xor)
                                                                    parseArgumentsOpt(x)
                                                                      listener: handleNoArguments(xor)
                                                                    listener: handleSend(x, xor)
                                                            rewriter()
                                                            parsePrecedenceExpression(^, 11, true)
                                                              parseUnaryExpression(^, true)
                                                                parsePrimary(^, expression)
                                                                  parseSendOrFunctionLiteral(^, expression)
                                                                    parseSend(^, expression)
                                                                      isNextIdentifier(^)
                                                                      ensureIdentifier(^, expression)
                                                                      parseArgumentsOpt(y)
                                                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                                                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                            rewriter()
                                                            listener: beginBinaryExpression(^)
                                                            parsePrecedenceExpression(^, 11, true)
                                                              parseUnaryExpression(^, true)
                                                                parsePrimary(^, expression)
                                                                  parseSendOrFunctionLiteral(^, expression)
                                                                    parseSend(^, expression)
                                                                      isNextIdentifier(^)
                                                                      ensureIdentifier(^, expression)
                                                                        listener: handleIdentifier(y, expression)
                                                                      listener: handleNoTypeArguments(})
                                                                      parseArgumentsOpt(y)
                                                                        listener: handleNoArguments(})
                                                                      listener: handleSend(y, })
                                                            listener: endBinaryExpression(^)
                                                        listener: handleInterpolationExpression(${, })
                                                        parseStringPart(})
                                                          listener: handleStringPart(")
                                                        listener: endLiteralString(1, ))
                                            listener: endArguments(1, (, ))
                                      listener: handleSend(print, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassConstructor(null, Key, (, :, })
              listener: endMember()
            notEofOrValue(}, Key)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(Key)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, Key)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(Key, methodDeclaration)
                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
                parseMethodTypeVar(Key)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(foo)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    isNextIdentifier(:)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(foo, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(foo)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(foo, =)
                            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(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                          listener: handleIdentifier(y, expression)
                                        listener: handleNoTypeArguments(,)
                                        parseArgumentsOpt(y)
                                          listener: handleNoArguments(,)
                                        listener: handleSend(y, ,)
                              listener: endBinaryExpression(^)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(bar)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(bar, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bar)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bar, =)
                            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(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                          listener: handleIdentifier(y, expression)
                                        listener: handleNoTypeArguments({)
                                        parseArgumentsOpt(y)
                                          listener: handleNoArguments({)
                                        listener: handleSend(y, {)
                              listener: endBinaryExpression(^)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(2, :, {)
                parseAsyncModifierOpt(y)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(y, 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)
                                      isNextIdentifier({)
                                      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 )
                                                        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(^, 11, true)
                                                              parseUnaryExpression(^, true)
                                                                parsePrimary(^, expression)
                                                                  parseSendOrFunctionLiteral(^, expression)
                                                                    parseSend(^, expression)
                                                                      isNextIdentifier(^)
                                                                      ensureIdentifier(^, expression)
                                                                        listener: handleIdentifier(y, expression)
                                                                      listener: handleNoTypeArguments(})
                                                                      parseArgumentsOpt(y)
                                                                        listener: handleNoArguments(})
                                                                      listener: handleSend(y, })
                                                            listener: endBinaryExpression(^)
                                                        listener: handleInterpolationExpression(${, })
                                                        parseStringPart(})
                                                          listener: handleStringPart(")
                                                        listener: endLiteralString(1, ))
                                            listener: endArguments(1, (, ))
                                      listener: handleSend(print, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassConstructor(null, Key, (, :, })
              listener: endMember()
            notEofOrValue(}, not_currently_working)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
              parseMetadataStar(})
                listener: beginMetadataStar(not_currently_working)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, not_currently_working, DeclarationKind.Class, Key, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, not_currently_working)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(not_currently_working, methodDeclaration)
                parseQualifiedRestOpt(not_currently_working, methodDeclarationContinuation)
                parseMethodTypeVar(not_currently_working)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(not_currently_working, not_currently_working, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(not_currently_working, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, 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, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(,)
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(y)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(y, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, x)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                        looksLikeLocalFunction(xor)
                        listener: beginMetadataStar(x)
                        listener: endMetadataStar(0)
                        listener: handleIdentifier(x, typeReference)
                        listener: handleNoTypeArguments(xor)
                        listener: handleType(x, null)
                        listener: beginVariablesDeclaration(xor, null, null)
                        parseVariablesDeclarationRest(x, true)
                          parseOptionallyInitializedIdentifier(x)
                            ensureIdentifier(x, localVariableDeclaration)
                              listener: handleIdentifier(xor, localVariableDeclaration)
                            listener: beginInitializedIdentifier(xor)
                            parseVariableInitializerOpt(xor)
                              listener: handleNoVariableInitializer(xor)
                            listener: endInitializedIdentifier(xor)
                          ensureSemicolon(xor)
                            reportRecoverableError(xor, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], xor, xor)
                            rewriter()
                          listener: endVariablesDeclaration(1, ;)
                  notEofOrValue(}, y)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                        looksLikeLocalFunction(y)
                        parseExpressionStatement(;)
                          parseExpression(;)
                            parsePrecedenceExpression(;, 1, true)
                              parseUnaryExpression(;, true)
                                parsePrimary(;, expression)
                                  parseSendOrFunctionLiteral(;, expression)
                                    parseSend(;, expression)
                                      isNextIdentifier(;)
                                      ensureIdentifier(;, expression)
                                        listener: handleIdentifier(y, expression)
                                      listener: handleNoTypeArguments(;)
                                      parseArgumentsOpt(y)
                                        listener: handleNoArguments(;)
                                      listener: handleSend(y, ;)
                          ensureSemicolon(y)
                          listener: handleExpressionStatement(;)
                  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(^, 11, true)
                                parseUnaryExpression(^, true)
                                  parsePrimary(^, expression)
                                    parseSendOrFunctionLiteral(^, expression)
                                      parseSend(^, expression)
                                        isNextIdentifier(^)
                                        ensureIdentifier(^, expression)
                                          listener: handleIdentifier(y, expression)
                                        listener: handleNoTypeArguments(;)
                                        parseArgumentsOpt(y)
                                          listener: handleNoArguments(;)
                                        listener: handleSend(y, ;)
                              listener: endBinaryExpression(^)
                          ensureSemicolon(y)
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(3, {, })
                listener: endClassMethod(null, not_currently_working, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 22, {, })
          listener: endClassDeclaration(abstract, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(abstract)
  listener: endCompilationUnit(1, )