parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Class, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, 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)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, augment, null, null, null, null, null, augment, Instance of 'NoType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, null, method)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(augment, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, augment, external, null, null, null, null, external, Instance of 'NoType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, null, method)
                listener: handleNoType(external)
                ensureIdentifierPotentiallyRecovered(external, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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: handleEmptyFunctionBody(;)
                listener: endClassMethod(null, augment, (, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'NoType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, null, method)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(augment, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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: handleEmptyFunctionBody(;)
                listener: endClassMethod(null, external, (, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, null, null, null, null, augment, Instance of 'VoidType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseMethod(}, null, augment, external, null, null, null, null, external, Instance of 'VoidType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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: handleEmptyFunctionBody(;)
                listener: endClassMethod(null, augment, (, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'VoidType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, 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: handleEmptyFunctionBody(;)
                listener: endClassMethod(null, external, (, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, null, null, null, null, augment, Instance of 'NoType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, get, getter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralNull(=>)
                              listener: handleLiteralNull(null)
                    ensureSemicolon(null)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, augment, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseMethod(;, null, augment, external, null, null, null, null, external, Instance of 'NoType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, get, getter)
                listener: handleNoType(external)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(;)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(;, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(get, augment, ;, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'NoType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, get, getter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(;)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(;, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(get, external, ;, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, null, null, null, null, augment, Instance of 'SimpleType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, get, getter)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, augment, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseMethod(;, null, augment, external, null, null, null, null, external, Instance of 'SimpleType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, get, getter)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(;)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(;, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(get, augment, ;, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'SimpleType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, get, getter)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(;)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(;, MemberKind.NonStaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(get, external, ;, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, null, null, null, null, augment, Instance of 'NoType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, set, setter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseMethod(}, null, augment, external, null, null, null, null, external, Instance of 'NoType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, set, setter)
                listener: handleNoType(external)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(set, augment, (, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'NoType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, set, setter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(set, external, (, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, null, null, null, null, augment, Instance of 'VoidType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, null, null, null, set, setter)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseMethod(}, null, augment, external, null, null, null, null, external, Instance of 'VoidType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, external, null, null, null, set, setter)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(set, augment, (, null, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, external, null, null, null, null, augment, Instance of 'VoidType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, external, null, null, null, set, setter)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(setter, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassMethod(set, external, (, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, null, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, null, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, null, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseFields(;, null, augment, external, null, null, null, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, external, null, null, null, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, external, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, external, null, null, null, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, external, null, null, null, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, external, null, null, null, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, external, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, external, null, null, null, var, 1, external, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, null, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, null, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, augment, null, null, null, null, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseFields(;, null, augment, external, null, null, null, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, external, null, null, null, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, external, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, external, null, null, null, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, external, null, null, null, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, external, null, null, null, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, external, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, external, null, null, null, final, 1, external, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, null, const, const, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, null, const, ;)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, augment, null, null, null, null, const, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseFields(;, null, augment, external, null, null, null, const, const, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, external, null, null, null, const, ;)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, external, const, DeclarationKind.Class, Class)
                  reportRecoverableError(field, Message[ConstFieldWithoutInitializer, The const variable 'field' must be initialized., Try adding an initializer ('= expression') to the declaration., {name: field}])
                    listener: handleRecoverableError(Message[ConstFieldWithoutInitializer, The const variable 'field' must be initialized., Try adding an initializer ('= expression') to the declaration., {name: field}], field, field)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, external, null, null, null, const, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, external, null, null, null, const, const, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, external, null, null, null, const, ;)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, external, const, DeclarationKind.Class, Class)
                  reportRecoverableError(field, Message[ConstFieldWithoutInitializer, The const variable 'field' must be initialized., Try adding an initializer ('= expression') to the declaration., {name: field}])
                    listener: handleRecoverableError(Message[ConstFieldWithoutInitializer, The const variable 'field' must be initialized., Try adding an initializer ('= expression') to the declaration., {name: field}], field, field)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, external, null, null, null, const, 1, external, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, null, null, augment, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, null, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, null, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableError(external, Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'external' and 'augment'., Try removing one of the keywords., {string: external, string2: augment}], external, external)
              listener: beginMember()
              parseFields(;, null, augment, external, null, null, null, null, external, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, external, null, null, null, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, external, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, external, null, null, null, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}])
                listener: handleRecoverableError(Message[ConflictingModifiers, Members can't be declared to be both 'augment' and 'external'., Try removing one of the keywords., {string: augment, string2: external}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, external, null, null, null, null, augment, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, external, null, null, null, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, external, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, external, null, null, null, null, 1, external, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, null, late, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, null, late, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, augment, null, null, null, late, null, late, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, null, null, late, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, null, null, late, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, augment, null, static, null, null, null, static, Instance of 'NoType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, null, method)
                listener: handleNoType(static)
                ensureIdentifierPotentiallyRecovered(static, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.StaticMethod)
                  parseFormalParameters(method, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, static, null, null, null, augment, Instance of 'NoType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, null, method)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(augment, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.StaticMethod)
                  parseFormalParameters(method, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, static, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, augment, null, static, null, null, null, static, Instance of 'VoidType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.StaticMethod)
                  parseFormalParameters(method, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, null, null, static, null, null, null, augment, Instance of 'VoidType', null, method, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.StaticMethod)
                  parseFormalParameters(method, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(null, static, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, augment, null, static, null, null, null, static, Instance of 'NoType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, get, getter)
                listener: handleNoType(static)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.StaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.StaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, false)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralNull(=>)
                              listener: handleLiteralNull(null)
                    ensureSemicolon(null)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, augment, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, null, static, null, null, null, augment, Instance of 'NoType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, get, getter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.StaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.StaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, false)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralNull(=>)
                              listener: handleLiteralNull(null)
                    ensureSemicolon(null)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, static, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, static, null, null, null, static, Instance of 'SimpleType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, get, getter)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.StaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.StaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, false)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, augment, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, null, null, static, null, null, null, augment, Instance of 'SimpleType', get, getter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, get, getter)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(getter, methodDeclaration)
                parseQualifiedRestOpt(getter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(getter, getter, true, MemberKind.StaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.StaticMethod)
                parseInitializersOpt(getter)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(getter)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(getter, false, false)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, static, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(;, null, augment, null, static, null, null, null, static, Instance of 'NoType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, set, setter)
                listener: handleNoType(static)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.StaticMethod)
                  parseFormalParameters(setter, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.StaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, null, null, static, null, null, null, augment, Instance of 'NoType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, set, setter)
                listener: handleNoType(augment)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.StaticMethod)
                  parseFormalParameters(setter, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.StaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, static, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, augment, null, static, null, null, null, static, Instance of 'VoidType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, augment, null, static, null, null, set, setter)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.StaticMethod)
                  parseFormalParameters(setter, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.StaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, augment, (, null, })
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseMethod(}, null, null, null, static, null, null, null, augment, Instance of 'VoidType', set, setter, DeclarationKind.Class, Class, false)
                listener: beginMethod(DeclarationKind.Class, null, null, static, null, null, set, setter)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(setter, methodDeclaration)
                parseQualifiedRestOpt(setter, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(setter, setter, false, MemberKind.StaticMethod)
                  parseFormalParameters(setter, MemberKind.StaticMethod)
                    parseFormalParametersRest((, MemberKind.StaticMethod)
                      listener: beginFormalParameters((, MemberKind.StaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(value)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(value, MemberKind.StaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(value, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.StaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.StaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, false)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassMethod(set, static, (, null, })
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
              parseMetadataStar(})
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(}, null, augment, null, static, null, null, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, null, var, })
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, static, null, null, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, null, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, null, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, static, null, null, var, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, null, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, null, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, augment, null, static, null, null, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, null, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, null, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, null, final, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, null, null, static, null, null, final, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, null, const, const, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, null, const, ;)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, augment, null, static, null, null, const, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, null, const, const, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, null, const, ;)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, null, const, DeclarationKind.Class, Class)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true)
                      parseUnaryExpression(=, true)
                        parsePrimary(=, expression)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(0)
                  listener: endFieldInitializer(=, ;)
                listener: endClassFields(null, null, null, static, null, null, const, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, null, null, static, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, null, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, static, null, null, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, null, null, augment, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, null, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, null, null, null, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, static, null, null, null, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, late, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, late, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, static, null, late, var, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, late, var, var, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, late, var, ;)
                listener: handleNoType(var)
                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, null, null, var, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, static, null, late, var, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, late, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, late, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, static, null, late, final, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, late, final, final, Instance of 'NoType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, late, final, ;)
                listener: handleNoType(final)
                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, null, null, final, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, static, null, late, final, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, augment)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(augment)
                listener: endMetadataStar(0)
              reportRecoverableErrorWithToken(augment, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[DuplicatedModifier, The modifier 'augment' was already specified., Try removing all but one occurrence of the modifier., {lexeme: augment}], augment, augment)
              listener: beginMember()
              parseFields(;, null, augment, null, static, null, late, null, late, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, augment, null, static, null, late, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, augment, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, augment, null, static, null, late, null, 1, augment, ;)
              listener: endMember()
            notEofOrValue(}, static)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
              parseMetadataStar(;)
                listener: beginMetadataStar(static)
                listener: endMetadataStar(0)
              reportRecoverableError(augment, Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}])
                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'augment' should be before the modifier 'static'., Try re-ordering the modifiers., {string: augment, string2: static}], augment, augment)
              listener: beginMember()
              parseFields(;, null, null, null, static, null, late, null, late, Instance of 'SimpleType', field, DeclarationKind.Class, Class, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, static, null, late, null, ;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(field)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(field, fieldDeclaration)
                parseFieldInitializerOpt(field, field, late, null, null, null, null, DeclarationKind.Class, Class)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, static, null, late, null, 1, static, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 65, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )