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