Problems reported:

parser/error_recovery/keyword_named_class_methods:12:7: 'assert' can't be used as an identifier because it's a keyword.
  int assert(int x) {
      ^^^^^^

parser/error_recovery/keyword_named_class_methods:14:12: `assert` can't be used as an expression.
    return assert(x-1) + 1;
           ^^^^^^

parser/error_recovery/keyword_named_class_methods:27:7: 'break' can't be used as an identifier because it's a keyword.
  int break(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:29:12: Expected an identifier, but got 'break'.
    return break(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:29:5: Expected ';' after this.
    return break(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:29:12: A break statement can't be used outside of a loop or switch statement.
    return break(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:29:12: Expected ';' after this.
    return break(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:32:7: 'case' can't be used as an identifier because it's a keyword.
  int case(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:34:12: 'case' can't be used as an identifier because it's a keyword.
    return case(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:37:7: 'catch' can't be used as an identifier because it's a keyword.
  int catch(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:39:12: 'catch' can't be used as an identifier because it's a keyword.
    return catch(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:42:7: 'class' can't be used as an identifier because it's a keyword.
  int class(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:44:12: 'class' can't be used as an identifier because it's a keyword.
    return class(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:47:7: 'const' can't be used as an identifier because it's a keyword.
  int const(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:49:17: Expected an identifier, but got '('.
    return const(x-1) + 1;
                ^

parser/error_recovery/keyword_named_class_methods:52:7: 'continue' can't be used as an identifier because it's a keyword.
  int continue(int x) {
      ^^^^^^^^

parser/error_recovery/keyword_named_class_methods:54:12: Expected an identifier, but got 'continue'.
    return continue(x-1) + 1;
           ^^^^^^^^

parser/error_recovery/keyword_named_class_methods:54:5: Expected ';' after this.
    return continue(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:54:12: A continue statement can't be used outside of a loop or switch statement.
    return continue(x-1) + 1;
           ^^^^^^^^

parser/error_recovery/keyword_named_class_methods:54:12: Expected ';' after this.
    return continue(x-1) + 1;
           ^^^^^^^^

parser/error_recovery/keyword_named_class_methods:62:7: 'default' can't be used as an identifier because it's a keyword.
  int default(int x) {
      ^^^^^^^

parser/error_recovery/keyword_named_class_methods:64:12: 'default' can't be used as an identifier because it's a keyword.
    return default(x-1) + 1;
           ^^^^^^^

parser/error_recovery/keyword_named_class_methods:72:7: 'do' can't be used as an identifier because it's a keyword.
  int do(int x) {
      ^^

parser/error_recovery/keyword_named_class_methods:74:12: Expected an identifier, but got 'do'.
    return do(x-1) + 1;
           ^^

parser/error_recovery/keyword_named_class_methods:74:5: Expected ';' after this.
    return do(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:75:3: Expected 'while' before this.
  }
  ^

parser/error_recovery/keyword_named_class_methods:75:3: Expected to find '('.
  }
  ^

parser/error_recovery/keyword_named_class_methods:75:3: Expected an identifier, but got '}'.
  }
  ^

parser/error_recovery/keyword_named_class_methods:74:23: Expected ';' after this.
    return do(x-1) + 1;
                      ^

parser/error_recovery/keyword_named_class_methods:82:7: 'else' can't be used as an identifier because it's a keyword.
  int else(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:84:12: Expected an identifier, but got 'else'.
    return else(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:84:5: Expected ';' after this.
    return else(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:84:12: Expected an identifier, but got 'else'.
    return else(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:84:5: Expected ';' after this.
    return else(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:84:12: Unexpected token ';'.
    return else(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:87:7: 'enum' can't be used as an identifier because it's a keyword.
  int enum(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:89:12: 'enum' can't be used as an identifier because it's a keyword.
    return enum(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:97:7: 'extends' can't be used as an identifier because it's a keyword.
  int extends(int x) {
      ^^^^^^^

parser/error_recovery/keyword_named_class_methods:99:12: 'extends' can't be used as an identifier because it's a keyword.
    return extends(x-1) + 1;
           ^^^^^^^

parser/error_recovery/keyword_named_class_methods:117:7: 'false' can't be used as an identifier because it's a keyword.
  int false(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:122:7: 'final' can't be used as an identifier because it's a keyword.
  int final(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:124:12: Expected an identifier, but got 'final'.
    return final(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:124:5: Expected ';' after this.
    return final(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:124:17: Expected an identifier, but got '('.
    return final(x-1) + 1;
                ^

parser/error_recovery/keyword_named_class_methods:124:17: Expected ';' after this.
    return final(x-1) + 1;
                ^

parser/error_recovery/keyword_named_class_methods:124:20: Expected ';' after this.
    return final(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:124:21: Expected an identifier, but got ')'.
    return final(x-1) + 1;
                    ^

parser/error_recovery/keyword_named_class_methods:124:20: Expected ';' after this.
    return final(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:124:21: Unexpected token ';'.
    return final(x-1) + 1;
                    ^

parser/error_recovery/keyword_named_class_methods:124:23: '+' is not a prefix operator.
    return final(x-1) + 1;
                      ^

parser/error_recovery/keyword_named_class_methods:127:7: 'finally' can't be used as an identifier because it's a keyword.
  int finally(int x) {
      ^^^^^^^

parser/error_recovery/keyword_named_class_methods:129:12: 'finally' can't be used as an identifier because it's a keyword.
    return finally(x-1) + 1;
           ^^^^^^^

parser/error_recovery/keyword_named_class_methods:132:7: 'for' can't be used as an identifier because it's a keyword.
  int for(int x) {
      ^^^

parser/error_recovery/keyword_named_class_methods:134:12: Expected an identifier, but got 'for'.
    return for(x-1) + 1;
           ^^^

parser/error_recovery/keyword_named_class_methods:134:5: Expected ';' after this.
    return for(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:134:18: Expected ';' after this.
    return for(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:134:19: Expected an identifier, but got ')'.
    return for(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_class_methods:134:18: Expected ';' after this.
    return for(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:134:21: '+' is not a prefix operator.
    return for(x-1) + 1;
                    ^

parser/error_recovery/keyword_named_class_methods:152:7: 'if' can't be used as an identifier because it's a keyword.
  int if(int x) {
      ^^

parser/error_recovery/keyword_named_class_methods:154:12: Expected an identifier, but got 'if'.
    return if(x-1) + 1;
           ^^

parser/error_recovery/keyword_named_class_methods:154:5: Expected ';' after this.
    return if(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:154:20: '+' is not a prefix operator.
    return if(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:167:7: 'in' can't be used as an identifier because it's a keyword.
  int in(int x) {
      ^^

parser/error_recovery/keyword_named_class_methods:169:12: 'in' can't be used as an identifier because it's a keyword.
    return in(x-1) + 1;
           ^^

parser/error_recovery/keyword_named_class_methods:182:7: 'is' can't be used as an identifier because it's a keyword.
  int is(int x) {
      ^^

parser/error_recovery/keyword_named_class_methods:184:12: Expected an identifier, but got 'is'.
    return is(x-1) + 1;
           ^^

parser/error_recovery/keyword_named_class_methods:184:16: Expected ')' before this.
    return is(x-1) + 1;
               ^

parser/error_recovery/keyword_named_class_methods:184:18: Record type fields list cannot contain only one element without a named field.
    return is(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:184:18: Expected ';' after this.
    return is(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:184:20: '+' is not a prefix operator.
    return is(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:207:7: 'new' can't be used as an identifier because it's a keyword.
  int new(int x) {
      ^^^

parser/error_recovery/keyword_named_class_methods:209:15: Expected an identifier, but got '('.
    return new(x-1) + 1;
              ^

parser/error_recovery/keyword_named_class_methods:212:7: 'null' can't be used as an identifier because it's a keyword.
  int null(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:252:7: 'rethrow' can't be used as an identifier because it's a keyword.
  int rethrow(int x) {
      ^^^^^^^

parser/error_recovery/keyword_named_class_methods:254:12: 'rethrow' can't be used as an identifier because it's a keyword.
    return rethrow(x-1) + 1;
           ^^^^^^^

parser/error_recovery/keyword_named_class_methods:257:7: 'return' can't be used as an identifier because it's a keyword.
  int return(int x) {
      ^^^^^^

parser/error_recovery/keyword_named_class_methods:259:12: Unexpected token 'return'.
    return return(x-1) + 1;
           ^^^^^^

parser/error_recovery/keyword_named_class_methods:282:7: 'super' can't be used as an identifier because it's a keyword.
  int super(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:282:7: Expected ';' after this.
  int super(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:282:12: Expected an identifier, but got '('.
  int super(int x) {
           ^

parser/error_recovery/keyword_named_class_methods:287:7: 'switch' can't be used as an identifier because it's a keyword.
  int switch(int x) {
      ^^^^^^

parser/error_recovery/keyword_named_class_methods:289:12: Expected an identifier, but got 'switch'.
    return switch(x-1) + 1;
           ^^^^^^

parser/error_recovery/keyword_named_class_methods:289:5: Expected ';' after this.
    return switch(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:289:22: A switch statement must have a body, even if it is empty.
    return switch(x-1) + 1;
                     ^

parser/error_recovery/keyword_named_class_methods:289:24: '+' is not a prefix operator.
    return switch(x-1) + 1;
                       ^

parser/error_recovery/keyword_named_class_methods:297:7: 'this' can't be used as an identifier because it's a keyword.
  int this(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:297:7: Expected ';' after this.
  int this(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:297:11: Expected an identifier, but got '('.
  int this(int x) {
          ^

parser/error_recovery/keyword_named_class_methods:302:7: 'throw' can't be used as an identifier because it's a keyword.
  int throw(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:307:7: 'true' can't be used as an identifier because it's a keyword.
  int true(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:312:7: 'try' can't be used as an identifier because it's a keyword.
  int try(int x) {
      ^^^

parser/error_recovery/keyword_named_class_methods:314:12: Expected an identifier, but got 'try'.
    return try(x-1) + 1;
           ^^^

parser/error_recovery/keyword_named_class_methods:314:5: Expected ';' after this.
    return try(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:314:12: A try statement must have a body, even if it is empty.
    return try(x-1) + 1;
           ^^^

parser/error_recovery/keyword_named_class_methods:314:12: A try block must be followed by an 'on', 'catch', or 'finally' clause.
    return try(x-1) + 1;
           ^^^

parser/error_recovery/keyword_named_class_methods:322:7: 'var' can't be used as an identifier because it's a keyword.
  int var(int x) {
      ^^^

parser/error_recovery/keyword_named_class_methods:324:12: Expected an identifier, but got 'var'.
    return var(x-1) + 1;
           ^^^

parser/error_recovery/keyword_named_class_methods:324:5: Expected ';' after this.
    return var(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:324:15: Expected an identifier, but got '('.
    return var(x-1) + 1;
              ^

parser/error_recovery/keyword_named_class_methods:324:15: Expected ';' after this.
    return var(x-1) + 1;
              ^

parser/error_recovery/keyword_named_class_methods:324:18: Expected ';' after this.
    return var(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:324:19: Expected an identifier, but got ')'.
    return var(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_class_methods:324:18: Expected ';' after this.
    return var(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_class_methods:324:19: Unexpected token ';'.
    return var(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_class_methods:324:21: '+' is not a prefix operator.
    return var(x-1) + 1;
                    ^

parser/error_recovery/keyword_named_class_methods:327:7: 'void' can't be used as an identifier because it's a keyword.
  int void(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:329:12: Expected an identifier, but got 'void'.
    return void(x-1) + 1;
           ^^^^

parser/error_recovery/keyword_named_class_methods:329:5: Expected ';' after this.
    return void(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:329:16: Expected an identifier, but got '('.
    return void(x-1) + 1;
               ^

parser/error_recovery/keyword_named_class_methods:329:16: Expected ';' after this.
    return void(x-1) + 1;
               ^

parser/error_recovery/keyword_named_class_methods:329:19: Expected ';' after this.
    return void(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_class_methods:329:20: Expected an identifier, but got ')'.
    return void(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:329:19: Expected ';' after this.
    return void(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_class_methods:329:20: Unexpected token ';'.
    return void(x-1) + 1;
                   ^

parser/error_recovery/keyword_named_class_methods:329:22: '+' is not a prefix operator.
    return void(x-1) + 1;
                     ^

parser/error_recovery/keyword_named_class_methods:332:7: 'while' can't be used as an identifier because it's a keyword.
  int while(int x) {
      ^^^^^

parser/error_recovery/keyword_named_class_methods:334:12: Expected an identifier, but got 'while'.
    return while(x-1) + 1;
           ^^^^^

parser/error_recovery/keyword_named_class_methods:334:5: Expected ';' after this.
    return while(x-1) + 1;
    ^^^^^^

parser/error_recovery/keyword_named_class_methods:334:23: '+' is not a prefix operator.
    return while(x-1) + 1;
                      ^

parser/error_recovery/keyword_named_class_methods:337:7: 'with' can't be used as an identifier because it's a keyword.
  int with(int x) {
      ^^^^

parser/error_recovery/keyword_named_class_methods:339:12: 'with' can't be used as an identifier because it's a keyword.
    return with(x-1) + 1;
           ^^^^

beginCompilationUnit(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
    handleIdentifier(WrapperClass, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, null, null, WrapperClass)
      handleNoType(WrapperClass)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, abstract)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(abstract)
            handleType(int, null)
            handleIdentifier(abstract, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(abstract, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(abstract, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, as)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(as)
            handleType(int, null)
            handleIdentifier(as, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(as, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(as, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, assert)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(assert)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert)
            handleIdentifier(assert, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                beginAssert(assert, Assert.Expression)
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                  handleRecoverableError(AssertAsExpression, assert, assert)
                endAssert(assert, Assert.Expression, (, null, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, async)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(async)
            handleType(int, null)
            handleIdentifier(async, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(async, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(async, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, await)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(await)
            handleType(int, null)
            handleIdentifier(await, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(await, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(await, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, break)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(break)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break)
            handleIdentifier(break, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break)
                handleIdentifier(, expression)
                handleNoTypeArguments(break)
                handleNoArguments(break)
                handleSend(, break)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              handleRecoverableError(BreakOutsideOfLoop, break, break)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
              handleBreakStatement(false, break, ;)
              beginParenthesizedExpressionOrRecordLiteral(()
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
              endParenthesizedExpression(()
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(4, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, case)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(case)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
            handleIdentifier(case, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
                handleIdentifier(case, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(case, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, catch)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(catch)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
            handleIdentifier(catch, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
                handleIdentifier(catch, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(catch, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, class)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(class)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
            handleIdentifier(class, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
                handleIdentifier(class, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(class, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, const)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(const)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const)
            handleIdentifier(const, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                beginConstExpression(const)
                  handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                  handleIdentifier(, constructorReference)
                  beginConstructorReference()
                    handleNoTypeArguments(()
                    handleNoConstructorReferenceContinuationAfterTypeArguments(()
                  endConstructorReference(, null, (, ConstructorReferenceContext.Const)
                  beginArguments(()
                    handleIdentifier(x, expression)
                    handleNoTypeArguments(-)
                    handleNoArguments(-)
                    handleSend(x, -)
                    beginBinaryExpression(-)
                      handleLiteralInt(1)
                    endBinaryExpression(-)
                  endArguments(1, (, ))
                endConstExpression(const)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, continue)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(continue)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue)
            handleIdentifier(continue, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue)
                handleIdentifier(, expression)
                handleNoTypeArguments(continue)
                handleNoArguments(continue)
                handleSend(, continue)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
              handleContinueStatement(false, continue, ;)
              beginParenthesizedExpressionOrRecordLiteral(()
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
              endParenthesizedExpression(()
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(4, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, covariant)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(covariant)
            handleType(int, null)
            handleIdentifier(covariant, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(covariant, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(covariant, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, default)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(default)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
            handleIdentifier(default, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
                handleIdentifier(default, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(default, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, deferred)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(deferred)
            handleType(int, null)
            handleIdentifier(deferred, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(deferred, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(deferred, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, do)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(do)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do)
            handleIdentifier(do, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do)
                handleIdentifier(, expression)
                handleNoTypeArguments(do)
                handleNoArguments(do)
                handleSend(, do)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginDoWhileStatement(do)
                beginDoWhileStatementBody(()
                  beginParenthesizedExpressionOrRecordLiteral(()
                    handleIdentifier(x, expression)
                    handleNoTypeArguments(-)
                    handleNoArguments(-)
                    handleSend(x, -)
                    beginBinaryExpression(-)
                      handleLiteralInt(1)
                    endBinaryExpression(-)
                  endParenthesizedExpression(()
                  beginBinaryExpression(+)
                    handleLiteralInt(1)
                  endBinaryExpression(+)
                  handleExpressionStatement(;)
                endDoWhileStatementBody(;)
                handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, })
                handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, })
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
                handleIdentifier(, expression)
                handleNoTypeArguments())
                handleNoArguments())
                handleSend(, ))
                handleParenthesizedCondition(()
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ;, ;)
              endDoWhileStatement(do, while, ;)
            endBlockFunctionBody(3, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, dynamic)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(dynamic)
            handleType(int, null)
            handleIdentifier(dynamic, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(dynamic, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(dynamic, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, else)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(else)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else)
            handleIdentifier(else, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
                handleIdentifier(, expression)
                handleNoTypeArguments(else)
                handleNoArguments(else)
                handleSend(, else)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
              handleIdentifier(, expression)
              handleNoTypeArguments(else)
              handleNoArguments(else)
              handleSend(, else)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              handleExpressionStatement(;)
              handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], else, else)
              beginParenthesizedExpressionOrRecordLiteral(()
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
              endParenthesizedExpression(()
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(4, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, enum)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(enum)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
            handleIdentifier(enum, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
                handleIdentifier(enum, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(enum, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, export)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(export)
            handleType(int, null)
            handleIdentifier(export, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(export, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(export, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, extends)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(extends)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
            handleIdentifier(extends, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
                handleIdentifier(extends, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(extends, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, extension)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(extension)
            handleType(int, null)
            handleIdentifier(extension, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(extension, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(extension, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, external)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(external)
            handleType(int, null)
            handleIdentifier(external, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(external, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(external, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, factory)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(factory)
            handleType(int, null)
            handleIdentifier(factory, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(factory, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(factory, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, false)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(false)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false)
            handleIdentifier(false, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleLiteralBool(false)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend((, ))
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, final)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(final)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final)
            handleIdentifier(final, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final)
                handleIdentifier(, expression)
                handleNoTypeArguments(final)
                handleNoArguments(final)
                handleSend(, final)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginMetadataStar(final)
              endMetadataStar(0)
              handleNoType(final)
              beginVariablesDeclaration((, null, final)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                handleIdentifier(, localVariableDeclaration)
                beginInitializedIdentifier()
                  handleNoVariableInitializer()
                endInitializedIdentifier()
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
              endVariablesDeclaration(1, ;)
              handleIdentifier(x, expression)
              handleNoTypeArguments(-)
              handleNoArguments(-)
              handleSend(x, -)
              beginBinaryExpression(-)
                handleLiteralInt(1)
              endBinaryExpression(-)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
              handleIdentifier(, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(, ))
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
              handleRecoverableError(UnsupportedPrefixPlus, +, +)
              handleIdentifier(, expression)
              handleNoTypeArguments(+)
              handleNoArguments(+)
              handleSend(, +)
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(6, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, finally)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(finally)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
            handleIdentifier(finally, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
                handleIdentifier(finally, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(finally, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, for)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(for)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for)
            handleIdentifier(for, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for)
                handleIdentifier(, expression)
                handleNoTypeArguments(for)
                handleNoArguments(for)
                handleSend(, for)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginForStatement(for)
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
                handleForInitializerExpressionStatement(1, false)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                handleIdentifier(, expression)
                handleNoTypeArguments())
                handleNoArguments())
                handleSend(, ))
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                handleExpressionStatement(;)
                handleForLoopParts(for, (, ;, 0)
                beginForStatementBody(+)
                  handleRecoverableError(UnsupportedPrefixPlus, +, +)
                  handleIdentifier(, expression)
                  handleNoTypeArguments(+)
                  handleNoArguments(+)
                  handleSend(, +)
                  beginBinaryExpression(+)
                    handleLiteralInt(1)
                  endBinaryExpression(+)
                  handleExpressionStatement(;)
                endForStatementBody(})
              endForStatement(})
            endBlockFunctionBody(3, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, Function)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(Function)
            handleType(int, null)
            handleIdentifier(Function, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(Function, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(Function, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, get)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(get)
            handleType(int, null)
            handleIdentifier(get, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(get, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(get, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, hide)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(hide)
            handleType(int, null)
            handleIdentifier(hide, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(hide, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(hide, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, if)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(if)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if)
            handleIdentifier(if, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if)
                handleIdentifier(, expression)
                handleNoTypeArguments(if)
                handleNoArguments(if)
                handleSend(, if)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
                handleParenthesizedCondition(()
                beginThenStatement(+)
                  handleRecoverableError(UnsupportedPrefixPlus, +, +)
                  handleIdentifier(, expression)
                  handleNoTypeArguments(+)
                  handleNoArguments(+)
                  handleSend(, +)
                  beginBinaryExpression(+)
                    handleLiteralInt(1)
                  endBinaryExpression(+)
                  handleExpressionStatement(;)
                endThenStatement(;)
              endIfStatement(if, null)
            endBlockFunctionBody(3, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, implements)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(implements)
            handleType(int, null)
            handleIdentifier(implements, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(implements, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(implements, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, import)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(import)
            handleType(int, null)
            handleIdentifier(import, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(import, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(import, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, in)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(in)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
            handleIdentifier(in, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
                handleIdentifier(in, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(in, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, inout)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(inout)
            handleType(int, null)
            handleIdentifier(inout, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(inout, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(inout, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, interface)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(interface)
            handleType(int, null)
            handleIdentifier(interface, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(interface, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(interface, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, is)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(is)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is)
            handleIdentifier(is, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is)
                handleIdentifier(, expression)
                handleNoTypeArguments(is)
                handleNoArguments(is)
                handleSend(, is)
                beginIsOperatorType(is)
                  beginRecordType(()
                    beginRecordTypeEntry()
                      beginMetadataStar(x)
                      endMetadataStar(0)
                      handleIdentifier(x, typeReference)
                      handleNoTypeArguments(-)
                      handleType(x, null)
                      handleNoName(-)
                    endRecordTypeEntry()
                    handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], -, -)
                    handleRecoverableError(OnlyOneRecordTypeFieldsList, ), ))
                  endRecordType((, null, 1)
                endIsOperatorType(is)
                handleIsOperator(is, null)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
              endReturnStatement(true, return, ;)
              handleRecoverableError(UnsupportedPrefixPlus, +, +)
              handleIdentifier(, expression)
              handleNoTypeArguments(+)
              handleNoArguments(+)
              handleSend(, +)
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(3, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, late)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(late)
            handleType(int, null)
            handleIdentifier(late, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(late, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(late, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, library)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(library)
            handleType(int, null)
            handleIdentifier(library, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(library, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(library, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, mixin)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(mixin)
            handleType(int, null)
            handleIdentifier(mixin, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(mixin, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(mixin, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, native)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(native)
            handleType(int, null)
            handleIdentifier(native, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(native, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(native, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, new)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(new)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new)
            handleIdentifier(new, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                beginNewExpression(new)
                  handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                  handleIdentifier(, constructorReference)
                  beginConstructorReference()
                    handleNoTypeArguments(()
                    handleNoConstructorReferenceContinuationAfterTypeArguments(()
                  endConstructorReference(, null, (, ConstructorReferenceContext.New)
                  beginArguments(()
                    handleIdentifier(x, expression)
                    handleNoTypeArguments(-)
                    handleNoArguments(-)
                    handleSend(x, -)
                    beginBinaryExpression(-)
                      handleLiteralInt(1)
                    endBinaryExpression(-)
                  endArguments(1, (, ))
                endNewExpression(new)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, null)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(null)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null)
            handleIdentifier(null, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleLiteralNull(null)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend((, ))
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, of)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(of)
            handleType(int, null)
            handleIdentifier(of, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(of, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(of, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, on)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(on)
            handleType(int, null)
            handleIdentifier(on, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(on, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(on, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, operator)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(operator)
            handleType(int, null)
            handleIdentifier(operator, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(operator, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(operator, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, out)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(out)
            handleType(int, null)
            handleIdentifier(out, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(out, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(out, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, part)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(part)
            handleType(int, null)
            handleIdentifier(part, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(part, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(part, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, patch)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(patch)
            handleType(int, null)
            handleIdentifier(patch, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(patch, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(patch, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, required)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(required)
            handleType(int, null)
            handleIdentifier(required, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(required, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(required, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, rethrow)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(rethrow)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
            handleIdentifier(rethrow, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
                handleIdentifier(rethrow, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(rethrow, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, return)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(return)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return)
            handleIdentifier(return, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
                beginParenthesizedExpressionOrRecordLiteral(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endParenthesizedExpression(()
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, set)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(set)
            handleType(int, null)
            handleIdentifier(set, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(set, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(set, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, show)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(show)
            handleType(int, null)
            handleIdentifier(show, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(show, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(show, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, source)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(source)
            handleType(int, null)
            handleIdentifier(source, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(source, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(source, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, static)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(static)
            handleType(int, null)
            handleIdentifier(static, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(static, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(static, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, })
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(super)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super)
            handleIdentifier(super, fieldDeclaration)
            handleNoFieldInitializer(()
            handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super)
          endClassFields(null, null, null, null, null, null, null, 1, int, ;)
        endMember()
        beginMetadataStar(()
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, ()
            handleNoType(;)
            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
            handleIdentifier(, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleSuperExpression(super, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(super, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, , (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, switch)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(switch)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch)
            handleIdentifier(switch, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch)
                handleIdentifier(, expression)
                handleNoTypeArguments(switch)
                handleNoArguments(switch)
                handleSend(, switch)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginSwitchStatement(switch)
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
                handleParenthesizedCondition(()
                handleRecoverableError(Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}], ), ))
                beginSwitchBlock({)
                endSwitchBlock(0, {, })
              endSwitchStatement(switch, })
              handleRecoverableError(UnsupportedPrefixPlus, +, +)
              handleIdentifier(, expression)
              handleNoTypeArguments(+)
              handleNoArguments(+)
              handleSend(, +)
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(4, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, sync)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(sync)
            handleType(int, null)
            handleIdentifier(sync, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(sync, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(sync, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, })
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(this)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this)
            handleIdentifier(this, fieldDeclaration)
            handleNoFieldInitializer(()
            handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], this, this)
          endClassFields(null, null, null, null, null, null, null, 1, int, ;)
        endMember()
        beginMetadataStar(()
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, ()
            handleNoType(;)
            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
            handleIdentifier(, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleThisExpression(this, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(this, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, , (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, throw)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(throw)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw)
            handleIdentifier(throw, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                beginParenthesizedExpressionOrRecordLiteral(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endParenthesizedExpression(()
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
                handleThrowExpression(throw, ;)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, true)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(true)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true)
            handleIdentifier(true, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleLiteralBool(true)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend((, ))
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, try)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(try)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try)
            handleIdentifier(try, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., Try inserting an identifier before 'try'., {lexeme: try}], try, try)
                handleIdentifier(, expression)
                handleNoTypeArguments(try)
                handleNoArguments(try)
                handleSend(, try)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginTryStatement(try)
                handleRecoverableError(Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}], try, try)
                beginBlock({, BlockKind(try statement))
                endBlock(0, {, }, BlockKind(try statement))
                handleRecoverableError(OnlyTry, try, try)
              endTryStatement(0, try, null)
              beginParenthesizedExpressionOrRecordLiteral(()
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
              endParenthesizedExpression(()
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(4, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, typedef)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(typedef)
            handleType(int, null)
            handleIdentifier(typedef, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(typedef, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(typedef, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, var)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(var)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var)
            handleIdentifier(var, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., Try inserting an identifier before 'var'., {lexeme: var}], var, var)
                handleIdentifier(, expression)
                handleNoTypeArguments(var)
                handleNoArguments(var)
                handleSend(, var)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginMetadataStar(var)
              endMetadataStar(0)
              handleNoType(var)
              beginVariablesDeclaration((, null, var)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                handleIdentifier(, localVariableDeclaration)
                beginInitializedIdentifier()
                  handleNoVariableInitializer()
                endInitializedIdentifier()
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
              endVariablesDeclaration(1, ;)
              handleIdentifier(x, expression)
              handleNoTypeArguments(-)
              handleNoArguments(-)
              handleSend(x, -)
              beginBinaryExpression(-)
                handleLiteralInt(1)
              endBinaryExpression(-)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
              handleIdentifier(, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(, ))
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
              handleRecoverableError(UnsupportedPrefixPlus, +, +)
              handleIdentifier(, expression)
              handleNoTypeArguments(+)
              handleNoArguments(+)
              handleSend(, +)
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(6, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, void)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(void)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void)
            handleIdentifier(void, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., Try inserting an identifier before 'void'., {lexeme: void}], void, void)
                handleIdentifier(, expression)
                handleNoTypeArguments(void)
                handleNoArguments(void)
                handleSend(, void)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginMetadataStar(void)
              endMetadataStar(0)
              handleVoidKeyword(void)
              beginVariablesDeclaration((, null, null)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                handleIdentifier(, localVariableDeclaration)
                beginInitializedIdentifier()
                  handleNoVariableInitializer()
                endInitializedIdentifier()
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
              endVariablesDeclaration(1, ;)
              handleIdentifier(x, expression)
              handleNoTypeArguments(-)
              handleNoArguments(-)
              handleSend(x, -)
              beginBinaryExpression(-)
                handleLiteralInt(1)
              endBinaryExpression(-)
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
              handleIdentifier(, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(, ))
              handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
              handleExpressionStatement(;)
              handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
              handleRecoverableError(UnsupportedPrefixPlus, +, +)
              handleIdentifier(, expression)
              handleNoTypeArguments(+)
              handleNoArguments(+)
              handleSend(, +)
              beginBinaryExpression(+)
                handleLiteralInt(1)
              endBinaryExpression(+)
              handleExpressionStatement(;)
            endBlockFunctionBody(6, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, while)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(while)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while)
            handleIdentifier(while, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., Try inserting an identifier before 'while'., {lexeme: while}], while, while)
                handleIdentifier(, expression)
                handleNoTypeArguments(while)
                handleNoArguments(while)
                handleSend(, while)
                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
              endReturnStatement(true, return, ;)
              beginWhileStatement(while)
                handleIdentifier(x, expression)
                handleNoTypeArguments(-)
                handleNoArguments(-)
                handleSend(x, -)
                beginBinaryExpression(-)
                  handleLiteralInt(1)
                endBinaryExpression(-)
                handleParenthesizedCondition(()
                beginWhileStatementBody(+)
                  handleRecoverableError(UnsupportedPrefixPlus, +, +)
                  handleIdentifier(, expression)
                  handleNoTypeArguments(+)
                  handleNoArguments(+)
                  handleSend(, +)
                  beginBinaryExpression(+)
                    handleLiteralInt(1)
                  endBinaryExpression(+)
                  handleExpressionStatement(;)
                endWhileStatementBody(})
              endWhileStatement(while, })
            endBlockFunctionBody(3, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, with)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(with)
            handleType(int, null)
            handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
            handleIdentifier(with, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
                handleIdentifier(with, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(with, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
        beginMetadataStar(int)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, yield)
            handleIdentifier(int, typeReference)
            handleNoTypeArguments(yield)
            handleType(int, null)
            handleIdentifier(yield, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(int)
              endMetadataStar(0)
              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                handleIdentifier(int, typeReference)
                handleNoTypeArguments(x)
                handleType(int, null)
                handleIdentifier(x, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
              beginIfStatement(if)
                handleIdentifier(x, expression)
                handleNoTypeArguments(==)
                handleNoArguments(==)
                handleSend(x, ==)
                beginBinaryExpression(==)
                  handleLiteralInt(0)
                endBinaryExpression(==)
                handleParenthesizedCondition(()
                beginThenStatement(return)
                  beginReturnStatement(return)
                    handleLiteralInt(42)
                  endReturnStatement(true, return, ;)
                endThenStatement(;)
              endIfStatement(if, null)
              beginReturnStatement(return)
                handleIdentifier(yield, expression)
                handleNoTypeArguments(()
                beginArguments(()
                  handleIdentifier(x, expression)
                  handleNoTypeArguments(-)
                  handleNoArguments(-)
                  handleSend(x, -)
                  beginBinaryExpression(-)
                    handleLiteralInt(1)
                  endBinaryExpression(-)
                endArguments(1, (, ))
                handleSend(yield, +)
                beginBinaryExpression(+)
                  handleLiteralInt(1)
                endBinaryExpression(+)
              endReturnStatement(true, return, ;)
            endBlockFunctionBody(2, {, })
          endClassMethod(null, int, (, null, })
        endMember()
      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 71, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration()
endCompilationUnit(1, )