parseUnit(augment)
  skipErrorTokens(augment)
  listener: beginCompilationUnit(augment)
  syntheticPreviousToken(augment)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(augment)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(augment)
      parseTopLevelMethod(, augment, null, augment, Instance of 'VoidType', null, topLevelMethod, false)
        listener: beginTopLevelMethod(, augment, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(topLevelMethod, topLevelFunctionDeclaration)
        parseMethodTypeVar(topLevelMethod)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(topLevelMethod, topLevelMethod, false, MemberKind.TopLevelMethod)
          parseFormalParameters(topLevelMethod, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, augment)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, false)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseAugmentSuperExpression({, expression)
                            listener: handleAugmentSuperExpression(augment, super, expression)
                            listener: handleNoTypeArguments(()
                            parseArguments(super)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                listener: endArguments(0, (, ))
                            listener: handleSend(augment, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(augment, null, })
  listener: endTopLevelDeclaration(augment)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(augment)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(augment)
      parseTopLevelMethod(}, augment, null, augment, Instance of 'VoidType', null, topLevelMethodError, false)
        listener: beginTopLevelMethod(}, augment, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(topLevelMethodError, topLevelFunctionDeclaration)
        parseMethodTypeVar(topLevelMethodError)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(topLevelMethodError, topLevelMethodError, false, MemberKind.TopLevelMethod)
          parseFormalParameters(topLevelMethodError, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, augment)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, false)
                reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'augment' here., Try removing 'augment'., {lexeme: augment}], augment, augment)
                parseExpressionStatementOrDeclarationAfterModifiers(augment, {, null, null, null, false)
                  looksLikeLocalFunction(local)
                  listener: beginMetadataStar(augment)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(local)
                  listener: handleType(int, null)
                  listener: beginVariablesDeclaration(local, null, null)
                  parseVariablesDeclarationRest(int, true)
                    parseOptionallyInitializedIdentifier(int)
                      ensureIdentifier(int, localVariableDeclaration)
                        listener: handleIdentifier(local, localVariableDeclaration)
                      listener: beginInitializedIdentifier(local)
                      parseVariableInitializerOpt(local)
                        listener: handleNoVariableInitializer(local)
                      listener: endInitializedIdentifier(local)
                    ensureSemicolon(local)
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, augment)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(augment)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            inPlainSync()
                            parseSendOrFunctionLiteral(;, expression)
                              parseSend(;, expression)
                                isNextIdentifier(;)
                                ensureIdentifier(;, expression)
                                  inPlainSync()
                                  listener: handleIdentifier(augment, expression)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(augment)
                                  listener: handleNoArguments(;)
                                listener: handleSend(augment, ;)
                    ensureSemicolon(augment)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(augment, null, })
  listener: endTopLevelDeclaration(augment)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(augment)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(augment)
      parseTopLevelMethod(}, augment, null, augment, Instance of 'SimpleTypeWith1Argument', get, topLevelProperty, false)
        listener: beginTopLevelMethod(}, augment, null)
        listener: handleIdentifier(List, typeReference)
        listener: beginTypeArguments(<)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(>)
        listener: handleType(int, null)
        listener: endTypeArguments(1, <, >)
        listener: handleType(List, null)
        ensureIdentifierPotentiallyRecovered(get, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(topLevelProperty, topLevelFunctionDeclaration)
        listener: handleNoTypeVariables({)
        parseGetterOrFormalParameters(topLevelProperty, topLevelProperty, true, MemberKind.TopLevelMethod)
          listener: handleNoFormalParameters({, MemberKind.TopLevelMethod)
        parseAsyncModifierOpt(topLevelProperty)
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        inPlainSync()
        parseFunctionBody(topLevelProperty, false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, return)
          parseStatement({)
            parseStatementX({)
              parseReturnStatement({)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        listener: handleNoTypeArguments([)
                        parseLiteralListSuffix(return, null)
                          parseExpression(...)
                            parsePrecedenceExpression(..., 1, true)
                              parseUnaryExpression(..., true)
                                parsePrimary(..., expression)
                                  parseAugmentSuperExpression(..., expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                          listener: handleSpreadExpression(...)
                          parseExpression(,)
                            parsePrecedenceExpression(,, 1, true)
                              parseUnaryExpression(,, true)
                                parsePrimary(,, expression)
                                  parseAugmentSuperExpression(,, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                              parseArgumentOrIndexStar(super, Instance of 'NoTypeParamOrArg', false)
                                parseExpression([)
                                  parsePrecedenceExpression([, 1, true)
                                    parseUnaryExpression([, true)
                                      parsePrimary([, expression)
                                        parseLiteralInt([)
                                          listener: handleLiteralInt(0)
                                listener: handleIndexedExpression(null, [, ])
                          listener: handleLiteralList(2, [, null, ])
                ensureSemicolon(])
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(augment, get, })
  listener: endTopLevelDeclaration(augment)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(augment)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(augment)
      parseTopLevelMethod(}, augment, null, augment, Instance of 'VoidType', set, topLevelProperty, false)
        listener: beginTopLevelMethod(}, augment, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(set, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(topLevelProperty, topLevelFunctionDeclaration)
        listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(topLevelProperty, topLevelProperty, false, MemberKind.TopLevelMethod)
          parseFormalParameters(topLevelProperty, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(List)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(List, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(List, typeReference)
                listener: beginTypeArguments(<)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(>)
                listener: handleType(int, null)
                listener: endTypeArguments(1, <, >)
                listener: handleType(List, null)
                ensureIdentifier(>, formalParameterDeclaration)
                  listener: handleIdentifier(value, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, augment)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, false)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseAugmentSuperExpression({, expression)
                            listener: handleAugmentSuperExpression(augment, super, expression)
                      parseArgumentOrIndexStar(super, Instance of 'NoTypeParamOrArg', false)
                        parseExpression([)
                          parsePrecedenceExpression([, 1, true)
                            parseUnaryExpression([, true)
                              parsePrimary([, expression)
                                parseLiteralInt([)
                                  listener: handleLiteralInt(0)
                        listener: handleIndexedExpression(null, [, ])
                      parsePrecedenceExpression(=, 1, true)
                        parseUnaryExpression(=, true)
                          parsePrimary(=, expression)
                            parseSendOrFunctionLiteral(=, expression)
                              parseSend(=, expression)
                                isNextIdentifier(=)
                                ensureIdentifier(=, expression)
                                  listener: handleIdentifier(value, expression)
                                listener: handleNoTypeArguments([)
                                parseArgumentsOpt(value)
                                  listener: handleNoArguments([)
                                listener: handleSend(value, [)
                        parseArgumentOrIndexStar(value, Instance of 'NoTypeParamOrArg', false)
                          parseExpression([)
                            parsePrecedenceExpression([, 1, true)
                              parseUnaryExpression([, true)
                                parsePrimary([, expression)
                                  parseLiteralInt([)
                                    listener: handleLiteralInt(1)
                          listener: handleIndexedExpression(null, [, ])
                      listener: handleAssignmentExpression(=)
                  ensureSemicolon(])
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, augment)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseAugmentSuperExpression(;, expression)
                            listener: handleAugmentSuperExpression(augment, super, expression)
                      parsePrecedenceExpression(=, 1, true)
                        parseUnaryExpression(=, true)
                          parsePrimary(=, expression)
                            parseSendOrFunctionLiteral(=, expression)
                              parseSend(=, expression)
                                isNextIdentifier(=)
                                ensureIdentifier(=, expression)
                                  listener: handleIdentifier(value, expression)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(value)
                                  listener: handleNoArguments(;)
                                listener: handleSend(value, ;)
                      listener: handleAssignmentExpression(=)
                  ensureSemicolon(value)
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(augment, set, })
  listener: endTopLevelDeclaration(void)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(void)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(void)
      parseTopLevelMethod(}, null, null, }, Instance of 'VoidType', null, injectedTopLevelMethod, false)
        listener: beginTopLevelMethod(}, null, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(injectedTopLevelMethod, topLevelFunctionDeclaration)
        parseMethodTypeVar(injectedTopLevelMethod)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(injectedTopLevelMethod, injectedTopLevelMethod, false, MemberKind.TopLevelMethod)
          parseFormalParameters(injectedTopLevelMethod, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, augment)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, false)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseAugmentSuperExpression({, expression)
                            listener: handleAugmentSuperExpression(augment, super, expression)
                            listener: handleNoTypeArguments(()
                            parseArguments(super)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                listener: endArguments(0, (, ))
                            listener: handleSend(augment, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, augment)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseAugmentSuperExpression(;, expression)
                            listener: handleAugmentSuperExpression(augment, super, expression)
                  ensureSemicolon(super)
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, augment)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'augment' here., Try removing 'augment'., {lexeme: augment}], augment, augment)
                parseExpressionStatementOrDeclarationAfterModifiers(augment, ;, null, null, null, false)
                  looksLikeLocalFunction(local)
                  listener: beginMetadataStar(augment)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(local)
                  listener: handleType(int, null)
                  listener: beginVariablesDeclaration(local, null, null)
                  parseVariablesDeclarationRest(int, true)
                    parseOptionallyInitializedIdentifier(int)
                      ensureIdentifier(int, localVariableDeclaration)
                        listener: handleIdentifier(local, localVariableDeclaration)
                      listener: beginInitializedIdentifier(local)
                      parseVariableInitializerOpt(local)
                        listener: handleNoVariableInitializer(local)
                      listener: endInitializedIdentifier(local)
                    ensureSemicolon(local)
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, augment)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(augment)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            inPlainSync()
                            parseSendOrFunctionLiteral(;, expression)
                              parseSend(;, expression)
                                isNextIdentifier(;)
                                ensureIdentifier(;, expression)
                                  inPlainSync()
                                  listener: handleIdentifier(augment, expression)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(augment)
                                  listener: handleNoArguments(;)
                                listener: handleSend(augment, ;)
                    ensureSemicolon(augment)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(void, null, })
  listener: endTopLevelDeclaration(augment)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(augment)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, augment, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Class, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, augment, Class)
        parseClass(Class, class, class, Class)
          parseClassHeaderOpt(Class, class, class)
            parseClassExtendsOpt(Class)
              listener: handleNoType(Class)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(Class)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(Class)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Class, DeclarationKind.Class, Class)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Class)
              parseMetadataStar({)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, augment, null, null, null, null, null, augment, Instance of 'VoidType', null, instanceMethod, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, null, instanceMethod)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(instanceMethod, methodDeclaration)
                parseQualifiedRestOpt(instanceMethod, methodDeclarationContinuation)
                parseMethodTypeVar(instanceMethod)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(instanceMethod, instanceMethod, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(instanceMethod, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, augment)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclaration({, false)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseAugmentSuperExpression({, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArguments(super)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                    listener: handleSend(augment, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, augment, null, null, null, null, null, augment, Instance of 'VoidType', null, instanceMethodErrors, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, null, instanceMethodErrors)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(instanceMethodErrors, methodDeclaration)
                parseQualifiedRestOpt(instanceMethodErrors, methodDeclarationContinuation)
                parseMethodTypeVar(instanceMethodErrors)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(instanceMethodErrors, instanceMethodErrors, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(instanceMethodErrors, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, augment)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclaration({, false)
                        reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                          listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'augment' here., Try removing 'augment'., {lexeme: augment}], augment, augment)
                        parseExpressionStatementOrDeclarationAfterModifiers(augment, {, null, null, null, false)
                          looksLikeLocalFunction(local)
                          listener: beginMetadataStar(augment)
                          listener: endMetadataStar(0)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(local)
                          listener: handleType(int, null)
                          listener: beginVariablesDeclaration(local, null, null)
                          parseVariablesDeclarationRest(int, true)
                            parseOptionallyInitializedIdentifier(int)
                              ensureIdentifier(int, localVariableDeclaration)
                                listener: handleIdentifier(local, localVariableDeclaration)
                              listener: beginInitializedIdentifier(local)
                              parseVariableInitializerOpt(local)
                                listener: handleNoVariableInitializer(local)
                              listener: endInitializedIdentifier(local)
                            ensureSemicolon(local)
                            listener: endVariablesDeclaration(1, ;)
                  notEofOrValue(}, augment)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclaration(;, false)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(augment)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrimary(;, expression)
                                    inPlainSync()
                                    parseSendOrFunctionLiteral(;, expression)
                                      parseSend(;, expression)
                                        isNextIdentifier(;)
                                        ensureIdentifier(;, expression)
                                          inPlainSync()
                                          listener: handleIdentifier(augment, expression)
                                        listener: handleNoTypeArguments(;)
                                        parseArgumentsOpt(augment)
                                          listener: handleNoArguments(;)
                                        listener: handleSend(augment, ;)
                            ensureSemicolon(augment)
                            listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(2, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, augment, null, null, null, null, null, augment, Instance of 'SimpleType', get, instanceProperty, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, get, instanceProperty)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(instanceProperty, methodDeclaration)
                parseQualifiedRestOpt(instanceProperty, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(instanceProperty, instanceProperty, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(instanceProperty)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(instanceProperty)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(instanceProperty, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, augment)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclaration({, false)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseAugmentSuperExpression({, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                              listener: handleUnaryPostfixAssignmentExpression(++)
                          ensureSemicolon(++)
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, --)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclaration(;, false)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(--)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrecedenceExpression(--, 16, true)
                                    parseUnaryExpression(--, true)
                                      parsePrimary(--, expression)
                                        parseAugmentSuperExpression(--, expression)
                                          listener: handleAugmentSuperExpression(augment, super, expression)
                                  listener: handleUnaryPrefixAssignmentExpression(--)
                            ensureSemicolon(super)
                            listener: handleExpressionStatement(;)
                  notEofOrValue(}, return)
                  parseStatement(;)
                    parseStatementX(;)
                      parseReturnStatement(;)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrecedenceExpression(-, 16, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseAugmentSuperExpression(-, expression)
                                      listener: handleAugmentSuperExpression(augment, super, expression)
                              listener: handleUnaryPrefixExpression(-)
                        ensureSemicolon(super)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(3, {, })
                listener: endClassMethod(get, augment, {, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, augment, null, null, null, null, null, augment, Instance of 'VoidType', set, instanceProperty, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, set, instanceProperty)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(instanceProperty, methodDeclaration)
                parseQualifiedRestOpt(instanceProperty, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(instanceProperty, instanceProperty, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(instanceProperty, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(value)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, augment)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclaration({, false)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseAugmentSuperExpression({, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                              parsePrecedenceExpression(=, 1, true)
                                parseUnaryExpression(=, true)
                                  parsePrimary(=, expression)
                                    parseSendOrFunctionLiteral(=, expression)
                                      parseSend(=, expression)
                                        isNextIdentifier(=)
                                        ensureIdentifier(=, expression)
                                          listener: handleIdentifier(value, expression)
                                        listener: handleNoTypeArguments(;)
                                        parseArgumentsOpt(value)
                                          listener: handleNoArguments(;)
                                        listener: handleSend(value, ;)
                              listener: handleAssignmentExpression(=)
                          ensureSemicolon(value)
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(set, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'VoidType', null, injectedInstanceMethod, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, injectedInstanceMethod)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(injectedInstanceMethod, methodDeclaration)
                parseQualifiedRestOpt(injectedInstanceMethod, methodDeclarationContinuation)
                parseMethodTypeVar(injectedInstanceMethod)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(injectedInstanceMethod, injectedInstanceMethod, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(injectedInstanceMethod, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, augment)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclaration({, false)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true)
                              parseUnaryExpression({, true)
                                parsePrimary({, expression)
                                  parseAugmentSuperExpression({, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArguments(super)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        listener: endArguments(0, (, ))
                                    listener: handleSend(augment, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, augment)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclaration(;, false)
                        parseExpressionStatement(;)
                          parseExpression(;)
                            parsePrecedenceExpression(;, 1, true)
                              parseUnaryExpression(;, true)
                                parsePrimary(;, expression)
                                  parseAugmentSuperExpression(;, expression)
                                    listener: handleAugmentSuperExpression(augment, super, expression)
                          ensureSemicolon(super)
                          listener: handleExpressionStatement(;)
                  notEofOrValue(}, augment)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclaration(;, false)
                        reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                          listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'augment' here., Try removing 'augment'., {lexeme: augment}], augment, augment)
                        parseExpressionStatementOrDeclarationAfterModifiers(augment, ;, null, null, null, false)
                          looksLikeLocalFunction(local)
                          listener: beginMetadataStar(augment)
                          listener: endMetadataStar(0)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(local)
                          listener: handleType(int, null)
                          listener: beginVariablesDeclaration(local, null, null)
                          parseVariablesDeclarationRest(int, true)
                            parseOptionallyInitializedIdentifier(int)
                              ensureIdentifier(int, localVariableDeclaration)
                                listener: handleIdentifier(local, localVariableDeclaration)
                              listener: beginInitializedIdentifier(local)
                              parseVariableInitializerOpt(local)
                                listener: handleNoVariableInitializer(local)
                              listener: endInitializedIdentifier(local)
                            ensureSemicolon(local)
                            listener: endVariablesDeclaration(1, ;)
                  notEofOrValue(}, augment)
                  parseStatement(;)
                    parseStatementX(;)
                      parseExpressionStatementOrDeclaration(;, false)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(augment)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrimary(;, expression)
                                    inPlainSync()
                                    parseSendOrFunctionLiteral(;, expression)
                                      parseSend(;, expression)
                                        isNextIdentifier(;)
                                        ensureIdentifier(;, expression)
                                          inPlainSync()
                                          listener: handleIdentifier(augment, expression)
                                        listener: handleNoTypeArguments(;)
                                        parseArgumentsOpt(augment)
                                          listener: handleNoArguments(;)
                                        listener: handleSend(augment, ;)
                            ensureSemicolon(augment)
                            listener: handleExpressionStatement(;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(4, {, })
                listener: endClassMethod(null, void, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 5, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(augment)
  listener: endCompilationUnit(6, )