COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java21 [2:49]
|   `--SEMI -> ; [2:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputUnnamedVariableBasic [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:40]
        |--LCURLY -> { [4:40]
        |--METHOD_DEF -> METHOD_DEF [5:9]
        |   |--MODIFIERS -> MODIFIERS [5:9]
        |   |   `--LITERAL_PRIVATE -> private [5:9]
        |   |--TYPE -> TYPE [5:17]
        |   |   `--LITERAL_VOID -> void [5:17]
        |   |--IDENT -> unnamedTest [5:22]
        |   |--LPAREN -> ( [5:33]
        |   |--PARAMETERS -> PARAMETERS [5:34]
        |   |--RPAREN -> ) [5:34]
        |   `--SLIST -> { [5:36]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [6:9]
        |       |   |--MODIFIERS -> MODIFIERS [6:9]
        |       |   |--TYPE -> TYPE [6:9]
        |       |   |   `--LITERAL_INT -> int [6:9]
        |       |   |--IDENT -> _ [6:13]
        |       |   `--ASSIGN -> = [6:15]
        |       |       `--EXPR -> EXPR [6:17]
        |       |           `--NUM_INT -> 0 [6:17]
        |       |--SEMI -> ; [6:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [7:9]
        |       |   |--MODIFIERS -> MODIFIERS [7:9]
        |       |   |--TYPE -> TYPE [7:9]
        |       |   |   `--LITERAL_INT -> int [7:9]
        |       |   |--IDENT -> _ [7:13]
        |       |   `--ASSIGN -> = [7:15]
        |       |       `--EXPR -> EXPR [7:17]
        |       |           `--NUM_INT -> 1 [7:17]
        |       |--SEMI -> ; [7:18]
        |       |--LITERAL_TRY -> try [8:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [8:13]
        |       |   |   |--LPAREN -> ( [8:13]
        |       |   |   |--RESOURCES -> RESOURCES [8:14]
        |       |   |   |   `--RESOURCE -> RESOURCE [8:14]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [8:14]
        |       |   |   |       |--TYPE -> TYPE [8:14]
        |       |   |   |       |   `--IDENT -> Lock [8:14]
        |       |   |   |       |--IDENT -> _ [8:19]
        |       |   |   |       `--ASSIGN -> = [8:21]
        |       |   |   |           `--EXPR -> EXPR [8:23]
        |       |   |   |               `--LITERAL_NULL -> null [8:23]
        |       |   |   `--RPAREN -> ) [8:27]
        |       |   `--SLIST -> { [8:29]
        |       |       |--LITERAL_TRY -> try [9:13]
        |       |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [9:17]
        |       |       |   |   |--LPAREN -> ( [9:17]
        |       |       |   |   |--RESOURCES -> RESOURCES [9:18]
        |       |       |   |   |   `--RESOURCE -> RESOURCE [9:18]
        |       |       |   |   |       |--MODIFIERS -> MODIFIERS [9:18]
        |       |       |   |   |       |--TYPE -> TYPE [9:18]
        |       |       |   |   |       |   `--IDENT -> Lock [9:18]
        |       |       |   |   |       |--IDENT -> _ [9:23]
        |       |       |   |   |       `--ASSIGN -> = [9:25]
        |       |       |   |   |           `--EXPR -> EXPR [9:27]
        |       |       |   |   |               `--LITERAL_NULL -> null [9:27]
        |       |       |   |   `--RPAREN -> ) [9:31]
        |       |       |   |--SLIST -> { [9:33]
        |       |       |   |   `--RCURLY -> } [10:13]
        |       |       |   `--LITERAL_CATCH -> catch [10:15]
        |       |       |       |--LPAREN -> ( [10:21]
        |       |       |       |--PARAMETER_DEF -> PARAMETER_DEF [10:22]
        |       |       |       |   |--MODIFIERS -> MODIFIERS [10:22]
        |       |       |       |   |--TYPE -> TYPE [10:22]
        |       |       |       |   |   `--IDENT -> Exception [10:22]
        |       |       |       |   `--IDENT -> _ [10:32]
        |       |       |       |--RPAREN -> ) [10:33]
        |       |       |       `--SLIST -> { [10:35]
        |       |       |           |--LITERAL_TRY -> try [11:17]
        |       |       |           |   |--SLIST -> { [11:21]
        |       |       |           |   |   `--RCURLY -> } [12:17]
        |       |       |           |   `--LITERAL_CATCH -> catch [12:19]
        |       |       |           |       |--LPAREN -> ( [12:25]
        |       |       |           |       |--PARAMETER_DEF -> PARAMETER_DEF [12:26]
        |       |       |           |       |   |--MODIFIERS -> MODIFIERS [12:26]
        |       |       |           |       |   |--TYPE -> TYPE [12:26]
        |       |       |           |       |   |   `--IDENT -> Exception [12:26]
        |       |       |           |       |   `--IDENT -> _ [12:36]
        |       |       |           |       |--RPAREN -> ) [12:37]
        |       |       |           |       `--SLIST -> { [12:39]
        |       |       |           |           `--RCURLY -> } [12:40]
        |       |       |           `--RCURLY -> } [13:13]
        |       |       `--RCURLY -> } [14:9]
        |       |--LITERAL_TRY -> try [15:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [15:13]
        |       |   |   |--LPAREN -> ( [15:13]
        |       |   |   |--RESOURCES -> RESOURCES [15:14]
        |       |   |   |   `--RESOURCE -> RESOURCE [15:14]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [15:14]
        |       |   |   |       |   `--FINAL -> final [15:14]
        |       |   |   |       |--TYPE -> TYPE [15:20]
        |       |   |   |       |   `--IDENT -> Lock [15:20]
        |       |   |   |       |--IDENT -> _ [15:25]
        |       |   |   |       `--ASSIGN -> = [15:27]
        |       |   |   |           `--EXPR -> EXPR [15:29]
        |       |   |   |               `--LITERAL_NULL -> null [15:29]
        |       |   |   `--RPAREN -> ) [15:33]
        |       |   `--SLIST -> { [15:35]
        |       |       `--RCURLY -> } [15:37]
        |       |--LITERAL_TRY -> try [16:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [16:13]
        |       |   |   |--LPAREN -> ( [16:13]
        |       |   |   |--RESOURCES -> RESOURCES [16:14]
        |       |   |   |   `--RESOURCE -> RESOURCE [16:14]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [16:14]
        |       |   |   |       |   `--ANNOTATION -> ANNOTATION [16:14]
        |       |   |   |       |       |--AT -> @ [16:14]
        |       |   |   |       |       `--IDENT -> Foo [16:15]
        |       |   |   |       |--TYPE -> TYPE [16:19]
        |       |   |   |       |   `--IDENT -> Lock [16:19]
        |       |   |   |       |--IDENT -> _ [16:24]
        |       |   |   |       `--ASSIGN -> = [16:26]
        |       |   |   |           `--EXPR -> EXPR [16:28]
        |       |   |   |               `--LITERAL_NULL -> null [16:28]
        |       |   |   `--RPAREN -> ) [16:32]
        |       |   `--SLIST -> { [16:34]
        |       |       `--RCURLY -> } [16:36]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [18:9]
        |       |   |--MODIFIERS -> MODIFIERS [18:9]
        |       |   |--TYPE -> TYPE [18:9]
        |       |   |   |--IDENT -> String [18:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [18:15]
        |       |   |       `--RBRACK -> ] [18:16]
        |       |   |--IDENT -> strs [18:18]
        |       |   `--ASSIGN -> = [18:23]
        |       |       `--EXPR -> EXPR [18:25]
        |       |           `--LITERAL_NEW -> new [18:25]
        |       |               |--IDENT -> String [18:29]
        |       |               |--ARRAY_DECLARATOR -> [ [18:35]
        |       |               |   `--RBRACK -> ] [18:36]
        |       |               `--ARRAY_INIT -> { [18:38]
        |       |                   |--EXPR -> EXPR [18:40]
        |       |                   |   `--STRING_LITERAL -> "str1" [18:40]
        |       |                   |--COMMA -> , [18:46]
        |       |                   |--EXPR -> EXPR [18:48]
        |       |                   |   `--STRING_LITERAL -> "str2" [18:48]
        |       |                   `--RCURLY -> } [18:55]
        |       |--SEMI -> ; [18:56]
        |       |--LITERAL_FOR -> for [19:9]
        |       |   |--LPAREN -> ( [19:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [19:14]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [19:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [19:14]
        |       |   |   |   |--TYPE -> TYPE [19:14]
        |       |   |   |   |   `--IDENT -> var [19:14]
        |       |   |   |   `--IDENT -> _ [19:18]
        |       |   |   |--COLON -> : [19:20]
        |       |   |   `--EXPR -> EXPR [19:22]
        |       |   |       `--IDENT -> strs [19:22]
        |       |   |--RPAREN -> ) [19:26]
        |       |   `--SLIST -> { [19:28]
        |       |       |--LITERAL_FOR -> for [20:13]
        |       |       |   |--LPAREN -> ( [20:17]
        |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [20:18]
        |       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [20:18]
        |       |       |   |   |   |--MODIFIERS -> MODIFIERS [20:18]
        |       |       |   |   |   |--TYPE -> TYPE [20:18]
        |       |       |   |   |   |   `--IDENT -> var [20:18]
        |       |       |   |   |   `--IDENT -> _ [20:22]
        |       |       |   |   |--COLON -> : [20:24]
        |       |       |   |   `--EXPR -> EXPR [20:26]
        |       |       |   |       `--IDENT -> strs [20:26]
        |       |       |   |--RPAREN -> ) [20:30]
        |       |       |   `--SLIST -> { [20:32]
        |       |       |       `--RCURLY -> } [21:13]
        |       |       `--RCURLY -> } [22:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [23:9]
        |       |   |--MODIFIERS -> MODIFIERS [23:9]
        |       |   |--TYPE -> TYPE [23:9]
        |       |   |   `--IDENT -> TwoParams [23:9]
        |       |   |--IDENT -> p1 [23:19]
        |       |   `--ASSIGN -> = [23:22]
        |       |       `--LAMBDA -> -> [23:31]
        |       |           |--LPAREN -> ( [23:24]
        |       |           |--PARAMETERS -> PARAMETERS [23:25]
        |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [23:25]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [23:25]
        |       |           |   |   |--TYPE -> TYPE [23:25]
        |       |           |   |   `--IDENT -> _ [23:25]
        |       |           |   |--COMMA -> , [23:26]
        |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [23:28]
        |       |           |       |--MODIFIERS -> MODIFIERS [23:28]
        |       |           |       |--TYPE -> TYPE [23:28]
        |       |           |       `--IDENT -> _ [23:28]
        |       |           |--RPAREN -> ) [23:29]
        |       |           `--SLIST -> { [23:34]
        |       |               `--RCURLY -> } [23:35]
        |       |--SEMI -> ; [23:36]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [24:9]
        |       |   |--MODIFIERS -> MODIFIERS [24:9]
        |       |   |--TYPE -> TYPE [24:9]
        |       |   |   `--IDENT -> TwoParams [24:9]
        |       |   |--IDENT -> p2 [24:19]
        |       |   `--ASSIGN -> = [24:22]
        |       |       `--LAMBDA -> -> [24:39]
        |       |           |--LPAREN -> ( [24:24]
        |       |           |--PARAMETERS -> PARAMETERS [24:25]
        |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [24:25]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [24:25]
        |       |           |   |   |--TYPE -> TYPE [24:25]
        |       |           |   |   |   `--IDENT -> var [24:25]
        |       |           |   |   `--IDENT -> _ [24:29]
        |       |           |   |--COMMA -> , [24:30]
        |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [24:32]
        |       |           |       |--MODIFIERS -> MODIFIERS [24:32]
        |       |           |       |--TYPE -> TYPE [24:32]
        |       |           |       |   `--IDENT -> var [24:32]
        |       |           |       `--IDENT -> _ [24:36]
        |       |           |--RPAREN -> ) [24:37]
        |       |           `--SLIST -> { [24:42]
        |       |               `--RCURLY -> } [24:43]
        |       |--SEMI -> ; [24:44]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [25:9]
        |       |   |--MODIFIERS -> MODIFIERS [25:9]
        |       |   |--TYPE -> TYPE [25:9]
        |       |   |   `--IDENT -> TwoIntParams [25:9]
        |       |   |--IDENT -> p3 [25:22]
        |       |   `--ASSIGN -> = [25:25]
        |       |       `--LAMBDA -> -> [25:42]
        |       |           |--LPAREN -> ( [25:27]
        |       |           |--PARAMETERS -> PARAMETERS [25:28]
        |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [25:28]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [25:28]
        |       |           |   |   |--TYPE -> TYPE [25:28]
        |       |           |   |   |   `--LITERAL_INT -> int [25:28]
        |       |           |   |   `--IDENT -> _ [25:32]
        |       |           |   |--COMMA -> , [25:33]
        |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [25:35]
        |       |           |       |--MODIFIERS -> MODIFIERS [25:35]
        |       |           |       |--TYPE -> TYPE [25:35]
        |       |           |       |   `--LITERAL_INT -> int [25:35]
        |       |           |       `--IDENT -> b [25:39]
        |       |           |--RPAREN -> ) [25:40]
        |       |           `--SLIST -> { [25:45]
        |       |               `--RCURLY -> } [25:46]
        |       |--SEMI -> ; [25:47]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [26:9]
        |       |   |--MODIFIERS -> MODIFIERS [26:9]
        |       |   |--TYPE -> TYPE [26:9]
        |       |   |   `--IDENT -> TwoIntParams [26:9]
        |       |   |--IDENT -> p4 [26:22]
        |       |   `--ASSIGN -> = [26:25]
        |       |       `--LAMBDA -> -> [26:42]
        |       |           |--LPAREN -> ( [26:27]
        |       |           |--PARAMETERS -> PARAMETERS [26:28]
        |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [26:28]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [26:28]
        |       |           |   |   |--TYPE -> TYPE [26:28]
        |       |           |   |   |   `--LITERAL_INT -> int [26:28]
        |       |           |   |   `--IDENT -> _ [26:32]
        |       |           |   |--COMMA -> , [26:33]
        |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [26:35]
        |       |           |       |--MODIFIERS -> MODIFIERS [26:35]
        |       |           |       |--TYPE -> TYPE [26:35]
        |       |           |       |   `--LITERAL_INT -> int [26:35]
        |       |           |       `--IDENT -> _ [26:39]
        |       |           |--RPAREN -> ) [26:40]
        |       |           `--SLIST -> { [26:45]
        |       |               `--RCURLY -> } [26:46]
        |       |--SEMI -> ; [26:47]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [27:9]
        |       |   |--MODIFIERS -> MODIFIERS [27:9]
        |       |   |--TYPE -> TYPE [27:9]
        |       |   |   `--IDENT -> TwoIntParamsIntRet [27:9]
        |       |   |--IDENT -> p5 [27:28]
        |       |   `--ASSIGN -> = [27:31]
        |       |       `--LAMBDA -> -> [27:48]
        |       |           |--LPAREN -> ( [27:33]
        |       |           |--PARAMETERS -> PARAMETERS [27:34]
        |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [27:34]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [27:34]
        |       |           |   |   |--TYPE -> TYPE [27:34]
        |       |           |   |   |   `--LITERAL_INT -> int [27:34]
        |       |           |   |   `--IDENT -> _ [27:38]
        |       |           |   |--COMMA -> , [27:39]
        |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [27:41]
        |       |           |       |--MODIFIERS -> MODIFIERS [27:41]
        |       |           |       |--TYPE -> TYPE [27:41]
        |       |           |       |   `--LITERAL_INT -> int [27:41]
        |       |           |       `--IDENT -> _ [27:45]
        |       |           |--RPAREN -> ) [27:46]
        |       |           `--SLIST -> { [27:51]
        |       |               |--LITERAL_RETURN -> return [27:53]
        |       |               |   |--EXPR -> EXPR [27:60]
        |       |               |   |   `--NUM_INT -> 1 [27:60]
        |       |               |   `--SEMI -> ; [27:61]
        |       |               `--RCURLY -> } [27:63]
        |       |--SEMI -> ; [27:64]
        |       |--EXPR -> EXPR [29:15]
        |       |   `--METHOD_CALL -> ( [29:15]
        |       |       |--DOT -> . [29:11]
        |       |       |   |--IDENT -> p1 [29:9]
        |       |       |   `--IDENT -> run [29:12]
        |       |       |--ELIST -> ELIST [29:16]
        |       |       |   |--EXPR -> EXPR [29:16]
        |       |       |   |   `--NUM_INT -> 1 [29:16]
        |       |       |   |--COMMA -> , [29:17]
        |       |       |   `--EXPR -> EXPR [29:19]
        |       |       |       `--NUM_INT -> 2 [29:19]
        |       |       `--RPAREN -> ) [29:20]
        |       |--SEMI -> ; [29:21]
        |       |--EXPR -> EXPR [30:15]
        |       |   `--METHOD_CALL -> ( [30:15]
        |       |       |--DOT -> . [30:11]
        |       |       |   |--IDENT -> p2 [30:9]
        |       |       |   `--IDENT -> run [30:12]
        |       |       |--ELIST -> ELIST [30:16]
        |       |       |   |--EXPR -> EXPR [30:16]
        |       |       |   |   `--NUM_INT -> 1 [30:16]
        |       |       |   |--COMMA -> , [30:17]
        |       |       |   `--EXPR -> EXPR [30:19]
        |       |       |       `--NUM_INT -> 2 [30:19]
        |       |       `--RPAREN -> ) [30:20]
        |       |--SEMI -> ; [30:21]
        |       |--EXPR -> EXPR [31:15]
        |       |   `--METHOD_CALL -> ( [31:15]
        |       |       |--DOT -> . [31:11]
        |       |       |   |--IDENT -> p3 [31:9]
        |       |       |   `--IDENT -> run [31:12]
        |       |       |--ELIST -> ELIST [31:16]
        |       |       |   |--EXPR -> EXPR [31:16]
        |       |       |   |   `--NUM_INT -> 1 [31:16]
        |       |       |   |--COMMA -> , [31:17]
        |       |       |   `--EXPR -> EXPR [31:19]
        |       |       |       `--NUM_INT -> 2 [31:19]
        |       |       `--RPAREN -> ) [31:20]
        |       |--SEMI -> ; [31:21]
        |       |--EXPR -> EXPR [32:15]
        |       |   `--METHOD_CALL -> ( [32:15]
        |       |       |--DOT -> . [32:11]
        |       |       |   |--IDENT -> p4 [32:9]
        |       |       |   `--IDENT -> run [32:12]
        |       |       |--ELIST -> ELIST [32:16]
        |       |       |   |--EXPR -> EXPR [32:16]
        |       |       |   |   `--NUM_INT -> 1 [32:16]
        |       |       |   |--COMMA -> , [32:17]
        |       |       |   `--EXPR -> EXPR [32:19]
        |       |       |       `--NUM_INT -> 2 [32:19]
        |       |       `--RPAREN -> ) [32:20]
        |       |--SEMI -> ; [32:21]
        |       |--EXPR -> EXPR [33:15]
        |       |   `--METHOD_CALL -> ( [33:15]
        |       |       |--DOT -> . [33:11]
        |       |       |   |--IDENT -> p5 [33:9]
        |       |       |   `--IDENT -> run [33:12]
        |       |       |--ELIST -> ELIST [33:16]
        |       |       |   |--EXPR -> EXPR [33:16]
        |       |       |   |   `--NUM_INT -> 1 [33:16]
        |       |       |   |--COMMA -> , [33:17]
        |       |       |   `--EXPR -> EXPR [33:19]
        |       |       |       `--NUM_INT -> 2 [33:19]
        |       |       `--RPAREN -> ) [33:20]
        |       |--SEMI -> ; [33:21]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [35:9]
        |       |   |--MODIFIERS -> MODIFIERS [35:9]
        |       |   |--TYPE -> TYPE [35:9]
        |       |   |   `--IDENT -> R [35:9]
        |       |   |--IDENT -> r [35:11]
        |       |   `--ASSIGN -> = [35:13]
        |       |       `--EXPR -> EXPR [35:15]
        |       |           `--LITERAL_NEW -> new [35:15]
        |       |               |--IDENT -> R [35:19]
        |       |               |--LPAREN -> ( [35:20]
        |       |               |--ELIST -> ELIST [35:21]
        |       |               |   `--EXPR -> EXPR [35:21]
        |       |               |       `--LITERAL_NULL -> null [35:21]
        |       |               `--RPAREN -> ) [35:25]
        |       |--SEMI -> ; [35:26]
        |       |--LITERAL_IF -> if [36:9]
        |       |   |--LPAREN -> ( [36:12]
        |       |   |--EXPR -> EXPR [36:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [36:15]
        |       |   |       |--IDENT -> r [36:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [36:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [36:26]
        |       |   |           |--TYPE -> TYPE [36:26]
        |       |   |           |   `--IDENT -> R [36:26]
        |       |   |           `--IDENT -> _ [36:28]
        |       |   |--RPAREN -> ) [36:29]
        |       |   `--SLIST -> { [36:31]
        |       |       `--RCURLY -> } [36:32]
        |       |--LITERAL_IF -> if [37:9]
        |       |   |--LPAREN -> ( [37:12]
        |       |   |--EXPR -> EXPR [37:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [37:15]
        |       |   |       |--IDENT -> r [37:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [37:26]
        |       |   |           |--TYPE -> TYPE [37:26]
        |       |   |           |   `--IDENT -> R [37:26]
        |       |   |           |--LPAREN -> ( [37:27]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:28]
        |       |   |           |   `--UNNAMED_PATTERN_DEF -> _ [37:28]
        |       |   |           `--RPAREN -> ) [37:29]
        |       |   |--RPAREN -> ) [37:30]
        |       |   `--SLIST -> { [37:32]
        |       |       `--RCURLY -> } [37:33]
        |       |--LITERAL_FOR -> for [38:9]
        |       |   |--LPAREN -> ( [38:13]
        |       |   |--FOR_INIT -> FOR_INIT [38:14]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [38:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [38:14]
        |       |   |   |   |--TYPE -> TYPE [38:14]
        |       |   |   |   |   `--LITERAL_INT -> int [38:14]
        |       |   |   |   |--IDENT -> _ [38:18]
        |       |   |   |   `--ASSIGN -> = [38:20]
        |       |   |   |       `--EXPR -> EXPR [38:22]
        |       |   |   |           `--NUM_INT -> 0 [38:22]
        |       |   |   |--COMMA -> , [38:23]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [38:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [38:14]
        |       |   |   |   |--TYPE -> TYPE [38:14]
        |       |   |   |   |   `--LITERAL_INT -> int [38:14]
        |       |   |   |   |--IDENT -> _ [38:25]
        |       |   |   |   `--ASSIGN -> = [38:27]
        |       |   |   |       `--EXPR -> EXPR [38:29]
        |       |   |   |           `--NUM_INT -> 1 [38:29]
        |       |   |   |--COMMA -> , [38:30]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [38:14]
        |       |   |       |--MODIFIERS -> MODIFIERS [38:14]
        |       |   |       |--TYPE -> TYPE [38:14]
        |       |   |       |   `--LITERAL_INT -> int [38:14]
        |       |   |       |--IDENT -> x [38:32]
        |       |   |       `--ASSIGN -> = [38:34]
        |       |   |           `--EXPR -> EXPR [38:36]
        |       |   |               `--NUM_INT -> 1 [38:36]
        |       |   |--SEMI -> ; [38:37]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [38:41]
        |       |   |   `--EXPR -> EXPR [38:41]
        |       |   |       `--LE -> <= [38:41]
        |       |   |           |--IDENT -> x [38:39]
        |       |   |           `--NUM_INT -> 1 [38:44]
        |       |   |--SEMI -> ; [38:46]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [38:49]
        |       |   |   `--ELIST -> ELIST [38:49]
        |       |   |       `--EXPR -> EXPR [38:49]
        |       |   |           `--POST_INC -> ++ [38:49]
        |       |   |               `--IDENT -> x [38:48]
        |       |   |--RPAREN -> ) [38:51]
        |       |   `--SLIST -> { [38:53]
        |       |       `--RCURLY -> } [38:54]
        |       `--RCURLY -> } [39:5]
        |--RECORD_DEF -> RECORD_DEF [42:5]
        |   |--MODIFIERS -> MODIFIERS [42:5]
        |   |--LITERAL_RECORD -> record [42:5]
        |   |--IDENT -> Point [42:12]
        |   |--LPAREN -> ( [42:17]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [42:18]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [42:18]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [42:18]
        |   |   |   |--TYPE -> TYPE [42:18]
        |   |   |   |   `--LITERAL_INT -> int [42:18]
        |   |   |   `--IDENT -> x [42:22]
        |   |   |--COMMA -> , [42:23]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [42:25]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [42:25]
        |   |       |--TYPE -> TYPE [42:25]
        |   |       |   `--LITERAL_INT -> int [42:25]
        |   |       `--IDENT -> y [42:29]
        |   |--RPAREN -> ) [42:30]
        |   `--OBJBLOCK -> OBJBLOCK [42:32]
        |       |--LCURLY -> { [42:32]
        |       `--RCURLY -> } [42:34]
        |--ENUM_DEF -> ENUM_DEF [43:5]
        |   |--MODIFIERS -> MODIFIERS [43:5]
        |   |--ENUM -> enum [43:5]
        |   |--IDENT -> Color [43:10]
        |   `--OBJBLOCK -> OBJBLOCK [43:16]
        |       |--LCURLY -> { [43:16]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [43:18]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [43:18]
        |       |   `--IDENT -> RED [43:18]
        |       |--COMMA -> , [43:21]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [43:23]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [43:23]
        |       |   `--IDENT -> GREEN [43:23]
        |       |--COMMA -> , [43:28]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [43:30]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [43:30]
        |       |   `--IDENT -> BLUE [43:30]
        |       `--RCURLY -> } [43:35]
        |--RECORD_DEF -> RECORD_DEF [44:5]
        |   |--MODIFIERS -> MODIFIERS [44:5]
        |   |--LITERAL_RECORD -> record [44:5]
        |   |--IDENT -> ColoredPoint [44:12]
        |   |--LPAREN -> ( [44:24]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [44:25]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [44:25]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [44:25]
        |   |   |   |--TYPE -> TYPE [44:25]
        |   |   |   |   `--IDENT -> Point [44:25]
        |   |   |   `--IDENT -> p [44:31]
        |   |   |--COMMA -> , [44:32]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [44:34]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [44:34]
        |   |       |--TYPE -> TYPE [44:34]
        |   |       |   `--IDENT -> Color [44:34]
        |   |       `--IDENT -> c [44:40]
        |   |--RPAREN -> ) [44:41]
        |   `--OBJBLOCK -> OBJBLOCK [44:43]
        |       |--LCURLY -> { [44:43]
        |       `--RCURLY -> } [44:45]
        |--METHOD_DEF -> METHOD_DEF [46:5]
        |   |--MODIFIERS -> MODIFIERS [46:5]
        |   |--TYPE -> TYPE [46:5]
        |   |   `--LITERAL_VOID -> void [46:5]
        |   |--IDENT -> jep443examples [46:10]
        |   |--LPAREN -> ( [46:24]
        |   |--PARAMETERS -> PARAMETERS [46:25]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [46:25]
        |   |       |--MODIFIERS -> MODIFIERS [46:25]
        |   |       |--TYPE -> TYPE [46:25]
        |   |       |   `--IDENT -> ColoredPoint [46:25]
        |   |       `--IDENT -> r [46:38]
        |   |--RPAREN -> ) [46:39]
        |   `--SLIST -> { [46:41]
        |       |--LITERAL_IF -> if [47:9]
        |       |   |--LPAREN -> ( [47:12]
        |       |   |--EXPR -> EXPR [47:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [47:15]
        |       |   |       |--IDENT -> r [47:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [47:26]
        |       |   |           |--TYPE -> TYPE [47:26]
        |       |   |           |   `--IDENT -> ColoredPoint [47:26]
        |       |   |           |--LPAREN -> ( [47:38]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:39]
        |       |   |           |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:39]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [47:39]
        |       |   |           |   |   |--TYPE -> TYPE [47:39]
        |       |   |           |   |   |   `--IDENT -> Point [47:39]
        |       |   |           |   |   |--LPAREN -> ( [47:44]
        |       |   |           |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:45]
        |       |   |           |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:45]
        |       |   |           |   |   |   |   |--MODIFIERS -> MODIFIERS [47:45]
        |       |   |           |   |   |   |   |--TYPE -> TYPE [47:45]
        |       |   |           |   |   |   |   |   `--LITERAL_INT -> int [47:45]
        |       |   |           |   |   |   |   `--IDENT -> x [47:49]
        |       |   |           |   |   |   |--COMMA -> , [47:50]
        |       |   |           |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:52]
        |       |   |           |   |   |       |--MODIFIERS -> MODIFIERS [47:52]
        |       |   |           |   |   |       |--TYPE -> TYPE [47:52]
        |       |   |           |   |   |       |   `--LITERAL_INT -> int [47:52]
        |       |   |           |   |   |       `--IDENT -> y [47:56]
        |       |   |           |   |   `--RPAREN -> ) [47:57]
        |       |   |           |   |--COMMA -> , [47:58]
        |       |   |           |   `--UNNAMED_PATTERN_DEF -> _ [47:60]
        |       |   |           `--RPAREN -> ) [47:61]
        |       |   |--RPAREN -> ) [47:62]
        |       |   `--SLIST -> { [47:64]
        |       |       `--RCURLY -> } [47:66]
        |       |--LITERAL_IF -> if [48:9]
        |       |   |--LPAREN -> ( [48:12]
        |       |   |--EXPR -> EXPR [48:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [48:15]
        |       |   |       |--IDENT -> r [48:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [48:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [48:26]
        |       |   |           |--TYPE -> TYPE [48:26]
        |       |   |           |   `--IDENT -> ColoredPoint [48:26]
        |       |   |           |--LPAREN -> ( [48:38]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [48:39]
        |       |   |           |   |--UNNAMED_PATTERN_DEF -> _ [48:39]
        |       |   |           |   |--COMMA -> , [48:40]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:42]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [48:42]
        |       |   |           |       |--TYPE -> TYPE [48:42]
        |       |   |           |       |   `--IDENT -> Color [48:42]
        |       |   |           |       `--IDENT -> c [48:48]
        |       |   |           `--RPAREN -> ) [48:49]
        |       |   |--RPAREN -> ) [48:50]
        |       |   `--SLIST -> { [48:52]
        |       |       `--RCURLY -> } [48:54]
        |       |--LITERAL_IF -> if [49:9]
        |       |   |--LPAREN -> ( [49:12]
        |       |   |--EXPR -> EXPR [49:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [49:15]
        |       |   |       |--IDENT -> r [49:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [49:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [49:26]
        |       |   |           |--TYPE -> TYPE [49:26]
        |       |   |           |   `--IDENT -> ColoredPoint [49:26]
        |       |   |           |--LPAREN -> ( [49:38]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [49:39]
        |       |   |           |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [49:39]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [49:39]
        |       |   |           |   |   |--TYPE -> TYPE [49:39]
        |       |   |           |   |   |   `--IDENT -> Point [49:39]
        |       |   |           |   |   |--LPAREN -> ( [49:44]
        |       |   |           |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [49:45]
        |       |   |           |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:45]
        |       |   |           |   |   |   |   |--MODIFIERS -> MODIFIERS [49:45]
        |       |   |           |   |   |   |   |--TYPE -> TYPE [49:45]
        |       |   |           |   |   |   |   |   `--LITERAL_INT -> int [49:45]
        |       |   |           |   |   |   |   `--IDENT -> x [49:49]
        |       |   |           |   |   |   |--COMMA -> , [49:50]
        |       |   |           |   |   |   `--UNNAMED_PATTERN_DEF -> _ [49:52]
        |       |   |           |   |   `--RPAREN -> ) [49:53]
        |       |   |           |   |--COMMA -> , [49:54]
        |       |   |           |   `--UNNAMED_PATTERN_DEF -> _ [49:56]
        |       |   |           `--RPAREN -> ) [49:57]
        |       |   |--RPAREN -> ) [49:58]
        |       |   `--SLIST -> { [49:60]
        |       |       `--RCURLY -> } [49:62]
        |       |--LITERAL_IF -> if [50:9]
        |       |   |--LPAREN -> ( [50:12]
        |       |   |--EXPR -> EXPR [50:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [50:15]
        |       |   |       |--IDENT -> r [50:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [50:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [50:26]
        |       |   |           |--TYPE -> TYPE [50:26]
        |       |   |           |   `--IDENT -> ColoredPoint [50:26]
        |       |   |           |--LPAREN -> ( [50:38]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [50:39]
        |       |   |           |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [50:39]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [50:39]
        |       |   |           |   |   |--TYPE -> TYPE [50:39]
        |       |   |           |   |   |   `--IDENT -> Point [50:39]
        |       |   |           |   |   |--LPAREN -> ( [50:44]
        |       |   |           |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [50:45]
        |       |   |           |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:45]
        |       |   |           |   |   |   |   |--MODIFIERS -> MODIFIERS [50:45]
        |       |   |           |   |   |   |   |--TYPE -> TYPE [50:45]
        |       |   |           |   |   |   |   |   `--LITERAL_INT -> int [50:45]
        |       |   |           |   |   |   |   `--IDENT -> x [50:49]
        |       |   |           |   |   |   |--COMMA -> , [50:50]
        |       |   |           |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:52]
        |       |   |           |   |   |       |--MODIFIERS -> MODIFIERS [50:52]
        |       |   |           |   |   |       |--TYPE -> TYPE [50:52]
        |       |   |           |   |   |       |   `--LITERAL_INT -> int [50:52]
        |       |   |           |   |   |       `--IDENT -> _ [50:56]
        |       |   |           |   |   `--RPAREN -> ) [50:57]
        |       |   |           |   |--COMMA -> , [50:58]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:60]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [50:60]
        |       |   |           |       |--TYPE -> TYPE [50:60]
        |       |   |           |       |   `--IDENT -> Color [50:60]
        |       |   |           |       `--IDENT -> _ [50:66]
        |       |   |           `--RPAREN -> ) [50:67]
        |       |   |--RPAREN -> ) [50:68]
        |       |   `--SLIST -> { [50:70]
        |       |       `--RCURLY -> } [50:72]
        |       |--LITERAL_IF -> if [51:9]
        |       |   |--LPAREN -> ( [51:12]
        |       |   |--EXPR -> EXPR [51:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [51:15]
        |       |   |       |--IDENT -> r [51:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [51:26]
        |       |   |           |--TYPE -> TYPE [51:26]
        |       |   |           |   `--IDENT -> ColoredPoint [51:26]
        |       |   |           `--IDENT -> _ [51:39]
        |       |   |--RPAREN -> ) [51:40]
        |       |   `--SLIST -> { [51:42]
        |       |       `--RCURLY -> } [51:44]
        |       `--RCURLY -> } [52:5]
        |--CLASS_DEF -> CLASS_DEF [54:5]
        |   |--MODIFIERS -> MODIFIERS [54:5]
        |   |--LITERAL_CLASS -> class [54:5]
        |   |--IDENT -> Lock [54:11]
        |   |--IMPLEMENTS_CLAUSE -> implements [54:16]
        |   |   `--IDENT -> AutoCloseable [54:27]
        |   `--OBJBLOCK -> OBJBLOCK [54:41]
        |       |--LCURLY -> { [54:41]
        |       |--METHOD_DEF -> METHOD_DEF [55:9]
        |       |   |--MODIFIERS -> MODIFIERS [55:9]
        |       |   |   |--ANNOTATION -> ANNOTATION [55:9]
        |       |   |   |   |--AT -> @ [55:9]
        |       |   |   |   `--IDENT -> Override [55:10]
        |       |   |   `--LITERAL_PUBLIC -> public [56:9]
        |       |   |--TYPE -> TYPE [56:16]
        |       |   |   `--LITERAL_VOID -> void [56:16]
        |       |   |--IDENT -> close [56:21]
        |       |   |--LPAREN -> ( [56:26]
        |       |   |--PARAMETERS -> PARAMETERS [56:27]
        |       |   |--RPAREN -> ) [56:27]
        |       |   `--SLIST -> { [56:29]
        |       |       `--RCURLY -> } [56:30]
        |       `--RCURLY -> } [57:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [58:5]
        |   |--MODIFIERS -> MODIFIERS [58:5]
        |   |--LITERAL_INTERFACE -> interface [58:5]
        |   |--IDENT -> TwoParams [58:15]
        |   `--OBJBLOCK -> OBJBLOCK [58:25]
        |       |--LCURLY -> { [58:25]
        |       |--METHOD_DEF -> METHOD_DEF [59:9]
        |       |   |--MODIFIERS -> MODIFIERS [59:9]
        |       |   |   `--LITERAL_PUBLIC -> public [59:9]
        |       |   |--TYPE -> TYPE [59:16]
        |       |   |   `--LITERAL_VOID -> void [59:16]
        |       |   |--IDENT -> run [59:21]
        |       |   |--LPAREN -> ( [59:24]
        |       |   |--PARAMETERS -> PARAMETERS [59:25]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [59:25]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [59:25]
        |       |   |   |   |--TYPE -> TYPE [59:25]
        |       |   |   |   |   `--IDENT -> Object [59:25]
        |       |   |   |   `--IDENT -> o1 [59:32]
        |       |   |   |--COMMA -> , [59:34]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [59:36]
        |       |   |       |--MODIFIERS -> MODIFIERS [59:36]
        |       |   |       |--TYPE -> TYPE [59:36]
        |       |   |       |   `--IDENT -> Object [59:36]
        |       |   |       `--IDENT -> o2 [59:43]
        |       |   |--RPAREN -> ) [59:45]
        |       |   `--SEMI -> ; [59:46]
        |       `--RCURLY -> } [60:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [61:5]
        |   |--MODIFIERS -> MODIFIERS [61:5]
        |   |--LITERAL_INTERFACE -> interface [61:5]
        |   |--IDENT -> TwoIntParams [61:15]
        |   `--OBJBLOCK -> OBJBLOCK [61:28]
        |       |--LCURLY -> { [61:28]
        |       |--METHOD_DEF -> METHOD_DEF [62:9]
        |       |   |--MODIFIERS -> MODIFIERS [62:9]
        |       |   |   `--LITERAL_PUBLIC -> public [62:9]
        |       |   |--TYPE -> TYPE [62:16]
        |       |   |   `--LITERAL_VOID -> void [62:16]
        |       |   |--IDENT -> run [62:21]
        |       |   |--LPAREN -> ( [62:24]
        |       |   |--PARAMETERS -> PARAMETERS [62:25]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [62:25]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [62:25]
        |       |   |   |   |--TYPE -> TYPE [62:25]
        |       |   |   |   |   `--LITERAL_INT -> int [62:25]
        |       |   |   |   `--IDENT -> o1 [62:29]
        |       |   |   |--COMMA -> , [62:31]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [62:33]
        |       |   |       |--MODIFIERS -> MODIFIERS [62:33]
        |       |   |       |--TYPE -> TYPE [62:33]
        |       |   |       |   `--LITERAL_INT -> int [62:33]
        |       |   |       `--IDENT -> o2 [62:37]
        |       |   |--RPAREN -> ) [62:39]
        |       |   `--SEMI -> ; [62:40]
        |       `--RCURLY -> } [63:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [64:5]
        |   |--MODIFIERS -> MODIFIERS [64:5]
        |   |--LITERAL_INTERFACE -> interface [64:5]
        |   |--IDENT -> TwoIntParamsIntRet [64:15]
        |   `--OBJBLOCK -> OBJBLOCK [64:34]
        |       |--LCURLY -> { [64:34]
        |       |--METHOD_DEF -> METHOD_DEF [65:9]
        |       |   |--MODIFIERS -> MODIFIERS [65:9]
        |       |   |   `--LITERAL_PUBLIC -> public [65:9]
        |       |   |--TYPE -> TYPE [65:16]
        |       |   |   `--LITERAL_INT -> int [65:16]
        |       |   |--IDENT -> run [65:20]
        |       |   |--LPAREN -> ( [65:23]
        |       |   |--PARAMETERS -> PARAMETERS [65:24]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [65:24]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [65:24]
        |       |   |   |   |--TYPE -> TYPE [65:24]
        |       |   |   |   |   `--LITERAL_INT -> int [65:24]
        |       |   |   |   `--IDENT -> a [65:28]
        |       |   |   |--COMMA -> , [65:29]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [65:31]
        |       |   |       |--MODIFIERS -> MODIFIERS [65:31]
        |       |   |       |--TYPE -> TYPE [65:31]
        |       |   |       |   `--LITERAL_INT -> int [65:31]
        |       |   |       `--IDENT -> b [65:35]
        |       |   |--RPAREN -> ) [65:36]
        |       |   `--SEMI -> ; [65:37]
        |       `--RCURLY -> } [66:5]
        |--RECORD_DEF -> RECORD_DEF [67:5]
        |   |--MODIFIERS -> MODIFIERS [67:5]
        |   |--LITERAL_RECORD -> record [67:5]
        |   |--IDENT -> R [67:12]
        |   |--LPAREN -> ( [67:13]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [67:14]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [67:14]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [67:14]
        |   |       |--TYPE -> TYPE [67:14]
        |   |       |   `--IDENT -> Object [67:14]
        |   |       `--IDENT -> o [67:21]
        |   |--RPAREN -> ) [67:22]
        |   `--OBJBLOCK -> OBJBLOCK [67:24]
        |       |--LCURLY -> { [67:24]
        |       `--RCURLY -> } [67:25]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [68:5]
        |   |--MODIFIERS -> MODIFIERS [68:5]
        |   |   `--LITERAL_PUBLIC -> public [68:5]
        |   |--AT -> @ [68:12]
        |   |--LITERAL_INTERFACE -> interface [68:13]
        |   |--IDENT -> Foo [68:23]
        |   `--OBJBLOCK -> OBJBLOCK [68:27]
        |       |--LCURLY -> { [68:27]
        |       `--RCURLY -> } [68:29]
        `--RCURLY -> } [69:1]
