Problems reported:

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

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

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

parser/error_recovery/keyword_named_top_level_methods:28:10: Expected an identifier, but got 'break'.
  return break(x-1) + 1;
         ^^^^^

parser/error_recovery/keyword_named_top_level_methods:28:3: Expected ';' after this.
  return break(x-1) + 1;
  ^^^^^^

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

parser/error_recovery/keyword_named_top_level_methods:28:10: Expected ';' after this.
  return break(x-1) + 1;
         ^^^^^

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

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

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

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

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

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

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

parser/error_recovery/keyword_named_top_level_methods:48:15: Expected an identifier, but got '('.
  return const(x-1) + 1;
              ^

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

parser/error_recovery/keyword_named_top_level_methods:53:10: Expected an identifier, but got 'continue'.
  return continue(x-1) + 1;
         ^^^^^^^^

parser/error_recovery/keyword_named_top_level_methods:53:3: Expected ';' after this.
  return continue(x-1) + 1;
  ^^^^^^

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

parser/error_recovery/keyword_named_top_level_methods:53:10: Expected ';' after this.
  return continue(x-1) + 1;
         ^^^^^^^^

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

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

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

parser/error_recovery/keyword_named_top_level_methods:73:10: Expected an identifier, but got 'do'.
  return do(x-1) + 1;
         ^^

parser/error_recovery/keyword_named_top_level_methods:73:3: Expected ';' after this.
  return do(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:74:1: Expected 'while' before this.
}
^

parser/error_recovery/keyword_named_top_level_methods:74:1: Expected to find '('.
}
^

parser/error_recovery/keyword_named_top_level_methods:74:1: Expected an identifier, but got '}'.
}
^

parser/error_recovery/keyword_named_top_level_methods:73:21: Expected ';' after this.
  return do(x-1) + 1;
                    ^

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

parser/error_recovery/keyword_named_top_level_methods:83:10: Expected an identifier, but got 'else'.
  return else(x-1) + 1;
         ^^^^

parser/error_recovery/keyword_named_top_level_methods:83:3: Expected ';' after this.
  return else(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:83:10: Expected an identifier, but got 'else'.
  return else(x-1) + 1;
         ^^^^

parser/error_recovery/keyword_named_top_level_methods:83:3: Expected ';' after this.
  return else(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:83:10: Unexpected token ';'.
  return else(x-1) + 1;
         ^^^^

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

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

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

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

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

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

parser/error_recovery/keyword_named_top_level_methods:123:10: Expected an identifier, but got 'final'.
  return final(x-1) + 1;
         ^^^^^

parser/error_recovery/keyword_named_top_level_methods:123:3: Expected ';' after this.
  return final(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:123:15: Expected an identifier, but got '('.
  return final(x-1) + 1;
              ^

parser/error_recovery/keyword_named_top_level_methods:123:15: Expected ';' after this.
  return final(x-1) + 1;
              ^

parser/error_recovery/keyword_named_top_level_methods:123:18: Expected ';' after this.
  return final(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_top_level_methods:123:19: Expected an identifier, but got ')'.
  return final(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_top_level_methods:123:18: Expected ';' after this.
  return final(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_top_level_methods:123:19: Unexpected token ';'.
  return final(x-1) + 1;
                  ^

parser/error_recovery/keyword_named_top_level_methods:123:21: '+' is not a prefix operator.
  return final(x-1) + 1;
                    ^

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

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

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

parser/error_recovery/keyword_named_top_level_methods:133:10: Expected an identifier, but got 'for'.
  return for(x-1) + 1;
         ^^^

parser/error_recovery/keyword_named_top_level_methods:133:3: Expected ';' after this.
  return for(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:133:16: Expected ';' after this.
  return for(x-1) + 1;
               ^

parser/error_recovery/keyword_named_top_level_methods:133:17: Expected an identifier, but got ')'.
  return for(x-1) + 1;
                ^

parser/error_recovery/keyword_named_top_level_methods:133:16: Expected ';' after this.
  return for(x-1) + 1;
               ^

parser/error_recovery/keyword_named_top_level_methods:133:19: '+' is not a prefix operator.
  return for(x-1) + 1;
                  ^

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

parser/error_recovery/keyword_named_top_level_methods:153:10: Expected an identifier, but got 'if'.
  return if(x-1) + 1;
         ^^

parser/error_recovery/keyword_named_top_level_methods:153:3: Expected ';' after this.
  return if(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:153:18: '+' is not a prefix operator.
  return if(x-1) + 1;
                 ^

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

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

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

parser/error_recovery/keyword_named_top_level_methods:183:10: Expected an identifier, but got 'is'.
  return is(x-1) + 1;
         ^^

parser/error_recovery/keyword_named_top_level_methods:183:12: Expected a type, but got '('.
  return is(x-1) + 1;
           ^

parser/error_recovery/keyword_named_top_level_methods:183:10: Expected ';' after this.
  return is(x-1) + 1;
         ^^

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

parser/error_recovery/keyword_named_top_level_methods:208:13: Expected an identifier, but got '('.
  return new(x-1) + 1;
            ^

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

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

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

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

parser/error_recovery/keyword_named_top_level_methods:258:10: Unexpected token 'return'.
  return return(x-1) + 1;
         ^^^^^^

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

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

parser/error_recovery/keyword_named_top_level_methods:288:10: Expected an identifier, but got 'switch'.
  return switch(x-1) + 1;
         ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:288:3: Expected ';' after this.
  return switch(x-1) + 1;
  ^^^^^^

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

parser/error_recovery/keyword_named_top_level_methods:288:22: '+' is not a prefix operator.
  return switch(x-1) + 1;
                     ^

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

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

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

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

parser/error_recovery/keyword_named_top_level_methods:313:10: Expected an identifier, but got 'try'.
  return try(x-1) + 1;
         ^^^

parser/error_recovery/keyword_named_top_level_methods:313:3: Expected ';' after this.
  return try(x-1) + 1;
  ^^^^^^

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

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

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

parser/error_recovery/keyword_named_top_level_methods:323:10: Expected an identifier, but got 'var'.
  return var(x-1) + 1;
         ^^^

parser/error_recovery/keyword_named_top_level_methods:323:3: Expected ';' after this.
  return var(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:323:13: Expected an identifier, but got '('.
  return var(x-1) + 1;
            ^

parser/error_recovery/keyword_named_top_level_methods:323:13: Expected ';' after this.
  return var(x-1) + 1;
            ^

parser/error_recovery/keyword_named_top_level_methods:323:16: Expected ';' after this.
  return var(x-1) + 1;
               ^

parser/error_recovery/keyword_named_top_level_methods:323:17: Expected an identifier, but got ')'.
  return var(x-1) + 1;
                ^

parser/error_recovery/keyword_named_top_level_methods:323:16: Expected ';' after this.
  return var(x-1) + 1;
               ^

parser/error_recovery/keyword_named_top_level_methods:323:17: Unexpected token ';'.
  return var(x-1) + 1;
                ^

parser/error_recovery/keyword_named_top_level_methods:323:19: '+' is not a prefix operator.
  return var(x-1) + 1;
                  ^

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

parser/error_recovery/keyword_named_top_level_methods:328:10: Expected an identifier, but got 'void'.
  return void(x-1) + 1;
         ^^^^

parser/error_recovery/keyword_named_top_level_methods:328:3: Expected ';' after this.
  return void(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:328:14: Expected an identifier, but got '('.
  return void(x-1) + 1;
             ^

parser/error_recovery/keyword_named_top_level_methods:328:14: Expected ';' after this.
  return void(x-1) + 1;
             ^

parser/error_recovery/keyword_named_top_level_methods:328:17: Expected ';' after this.
  return void(x-1) + 1;
                ^

parser/error_recovery/keyword_named_top_level_methods:328:18: Expected an identifier, but got ')'.
  return void(x-1) + 1;
                 ^

parser/error_recovery/keyword_named_top_level_methods:328:17: Expected ';' after this.
  return void(x-1) + 1;
                ^

parser/error_recovery/keyword_named_top_level_methods:328:18: Unexpected token ';'.
  return void(x-1) + 1;
                 ^

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

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

parser/error_recovery/keyword_named_top_level_methods:333:10: Expected an identifier, but got 'while'.
  return while(x-1) + 1;
         ^^^^^

parser/error_recovery/keyword_named_top_level_methods:333:3: Expected ';' after this.
  return while(x-1) + 1;
  ^^^^^^

parser/error_recovery/keyword_named_top_level_methods:333:21: '+' is not a prefix operator.
  return while(x-1) + 1;
                    ^

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

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

beginCompilationUnit(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(abstract)
      handleType(int, null)
      handleIdentifier(abstract, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(as)
      handleType(int, null)
      handleIdentifier(as, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(async)
      handleType(int, null)
      handleIdentifier(async, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(await)
      handleType(int, null)
      handleIdentifier(await, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, ;)
        handleIdentifier(x, expression)
        handleNoTypeArguments(-)
        handleNoArguments(-)
        handleSend(x, -)
        beginBinaryExpression(-)
          handleLiteralInt(1)
        endBinaryExpression(-)
        handleParenthesizedExpression(()
        beginBinaryExpression(+)
          handleLiteralInt(1)
        endBinaryExpression(+)
        handleExpressionStatement(;)
      endBlockFunctionBody(4, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, ;)
        handleIdentifier(x, expression)
        handleNoTypeArguments(-)
        handleNoArguments(-)
        handleSend(x, -)
        beginBinaryExpression(-)
          handleLiteralInt(1)
        endBinaryExpression(-)
        handleParenthesizedExpression(()
        beginBinaryExpression(+)
          handleLiteralInt(1)
        endBinaryExpression(+)
        handleExpressionStatement(;)
      endBlockFunctionBody(4, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(covariant)
      handleType(int, null)
      handleIdentifier(covariant, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(deferred)
      handleType(int, null)
      handleIdentifier(deferred, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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(()
            handleIdentifier(x, expression)
            handleNoTypeArguments(-)
            handleNoArguments(-)
            handleSend(x, -)
            beginBinaryExpression(-)
              handleLiteralInt(1)
            endBinaryExpression(-)
            handleParenthesizedExpression(()
            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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(dynamic)
      handleType(int, null)
      handleIdentifier(dynamic, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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)
        handleIdentifier(x, expression)
        handleNoTypeArguments(-)
        handleNoArguments(-)
        handleSend(x, -)
        beginBinaryExpression(-)
          handleLiteralInt(1)
        endBinaryExpression(-)
        handleParenthesizedExpression(()
        beginBinaryExpression(+)
          handleLiteralInt(1)
        endBinaryExpression(+)
        handleExpressionStatement(;)
      endBlockFunctionBody(4, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(export)
      handleType(int, null)
      handleIdentifier(export, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(extension)
      handleType(int, null)
      handleIdentifier(extension, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(external)
      handleType(int, null)
      handleIdentifier(external, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(factory)
      handleType(int, null)
      handleIdentifier(factory, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(Function)
      handleType(int, null)
      handleIdentifier(Function, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(get)
      handleType(int, null)
      handleIdentifier(get, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(hide)
      handleType(int, null)
      handleIdentifier(hide, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(implements)
      handleType(int, null)
      handleIdentifier(implements, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(import)
      handleType(int, null)
      handleIdentifier(import, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(inout)
      handleType(int, null)
      handleIdentifier(inout, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(interface)
      handleType(int, null)
      handleIdentifier(interface, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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)
            handleRecoverableError(Message[ExpectedType, Expected a type, but got '('., null, {lexeme: (}], (, ()
            handleIdentifier(, typeReference)
            handleNoTypeArguments(()
            handleType(, null)
          endIsOperatorType(is)
          handleIsOperator(is, null)
          handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], is, is)
        endReturnStatement(true, return, ;)
        handleIdentifier(x, expression)
        handleNoTypeArguments(-)
        handleNoArguments(-)
        handleSend(x, -)
        beginBinaryExpression(-)
          handleLiteralInt(1)
        endBinaryExpression(-)
        handleParenthesizedExpression(()
        beginBinaryExpression(+)
          handleLiteralInt(1)
        endBinaryExpression(+)
        handleExpressionStatement(;)
      endBlockFunctionBody(3, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(late)
      handleType(int, null)
      handleIdentifier(late, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(library)
      handleType(int, null)
      handleIdentifier(library, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(mixin)
      handleType(int, null)
      handleIdentifier(mixin, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(native)
      handleType(int, null)
      handleIdentifier(native, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, 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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(of)
      handleType(int, null)
      handleIdentifier(of, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(on)
      handleType(int, null)
      handleIdentifier(on, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(operator)
      handleType(int, null)
      handleIdentifier(operator, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(out)
      handleType(int, null)
      handleIdentifier(out, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(part)
      handleType(int, null)
      handleIdentifier(part, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(patch)
      handleType(int, null)
      handleIdentifier(patch, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(required)
      handleType(int, null)
      handleIdentifier(required, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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)
          handleIdentifier(x, expression)
          handleNoTypeArguments(-)
          handleNoArguments(-)
          handleSend(x, -)
          beginBinaryExpression(-)
            handleLiteralInt(1)
          endBinaryExpression(-)
          handleParenthesizedExpression(()
          beginBinaryExpression(+)
            handleLiteralInt(1)
          endBinaryExpression(+)
        endReturnStatement(true, return, ;)
      endBlockFunctionBody(2, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(set)
      handleType(int, null)
      handleIdentifier(set, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(show)
      handleType(int, null)
      handleIdentifier(show, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(source)
      handleType(int, null)
      handleIdentifier(source, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(static)
      handleType(int, null)
      handleIdentifier(static, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, 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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(sync)
      handleType(int, null)
      handleIdentifier(sync, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, 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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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(x, expression)
          handleNoTypeArguments(-)
          handleNoArguments(-)
          handleSend(x, -)
          beginBinaryExpression(-)
            handleLiteralInt(1)
          endBinaryExpression(-)
          handleParenthesizedExpression(()
          beginBinaryExpression(+)
            handleLiteralInt(1)
          endBinaryExpression(+)
          handleThrowExpression(throw, ;)
        endReturnStatement(true, return, ;)
      endBlockFunctionBody(2, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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)
        handleIdentifier(x, expression)
        handleNoTypeArguments(-)
        handleNoArguments(-)
        handleSend(x, -)
        beginBinaryExpression(-)
          handleLiteralInt(1)
        endBinaryExpression(-)
        handleParenthesizedExpression(()
        beginBinaryExpression(+)
          handleLiteralInt(1)
        endBinaryExpression(+)
        handleExpressionStatement(;)
      endBlockFunctionBody(4, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(typedef)
      handleType(int, null)
      handleIdentifier(typedef, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      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, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration(int)
  beginMetadataStar(int)
  endMetadataStar(0)
  beginTopLevelMember(int)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(yield)
      handleType(int, null)
      handleIdentifier(yield, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(int)
        endMetadataStar(0)
        beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(int, typeReference)
          handleNoTypeArguments(x)
          handleType(int, null)
          handleIdentifier(x, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
      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, {, })
    endTopLevelMethod(int, null, })
  endTopLevelDeclaration()
endCompilationUnit(69, )