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 -> java20 [2:49]
|   `--SEMI -> ; [2:55]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> List [4:18]
|   `--SEMI -> ; [4:22]
`--CLASS_DEF -> CLASS_DEF [6:1]
    |--MODIFIERS -> MODIFIERS [6:1]
    |   `--LITERAL_PUBLIC -> public [6:1]
    |--LITERAL_CLASS -> class [6:8]
    |--IDENT -> InputJava20RecordDecompositionEnhancedForLoopTricky [6:14]
    `--OBJBLOCK -> OBJBLOCK [6:66]
        |--LCURLY -> { [6:66]
        |--METHOD_DEF -> METHOD_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |--TYPE -> TYPE [7:5]
        |   |   `--LITERAL_VOID -> void [7:5]
        |   |--IDENT -> m [7:10]
        |   |--LPAREN -> ( [7:11]
        |   |--PARAMETERS -> PARAMETERS [7:12]
        |   |--RPAREN -> ) [7:12]
        |   `--SLIST -> { [7:14]
        |       |--LITERAL_FOR -> for [9:9]
        |       |   |--LPAREN -> ( [9:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [9:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [9:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [9:14]
        |       |   |   |   |--TYPE -> TYPE [9:14]
        |       |   |   |   |   `--IDENT -> Point [9:14]
        |       |   |   |   |--LPAREN -> ( [9:19]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [9:20]
        |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:20]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [9:20]
        |       |   |   |   |   |   |   `--ANNOTATION -> ANNOTATION [9:20]
        |       |   |   |   |   |   |       |--AT -> @ [9:20]
        |       |   |   |   |   |   |       `--IDENT -> A [9:21]
        |       |   |   |   |   |   |--TYPE -> TYPE [9:23]
        |       |   |   |   |   |   |   `--IDENT -> var [9:23]
        |       |   |   |   |   |   `--IDENT -> x [9:27]
        |       |   |   |   |   |--COMMA -> , [9:28]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:30]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [9:30]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [9:30]
        |       |   |   |   |       |   |   |--AT -> @ [9:30]
        |       |   |   |   |       |   |   `--IDENT -> A [9:31]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [9:33]
        |       |   |   |   |       |       |--AT -> @ [9:33]
        |       |   |   |   |       |       `--IDENT -> B [9:34]
        |       |   |   |   |       |--TYPE -> TYPE [9:36]
        |       |   |   |   |       |   `--IDENT -> var [9:36]
        |       |   |   |   |       `--IDENT -> y [9:40]
        |       |   |   |   `--RPAREN -> ) [9:41]
        |       |   |   |--COLON -> : [9:43]
        |       |   |   `--EXPR -> EXPR [10:24]
        |       |   |       `--METHOD_CALL -> ( [10:24]
        |       |   |           |--DOT -> . [10:21]
        |       |   |           |   |--IDENT -> List [10:17]
        |       |   |           |   `--IDENT -> of [10:22]
        |       |   |           |--ELIST -> ELIST [10:25]
        |       |   |           |   `--EXPR -> EXPR [10:25]
        |       |   |           |       `--LITERAL_NEW -> new [10:25]
        |       |   |           |           |--IDENT -> Point [10:29]
        |       |   |           |           |--LPAREN -> ( [10:34]
        |       |   |           |           |--ELIST -> ELIST [10:35]
        |       |   |           |           |   |--EXPR -> EXPR [10:35]
        |       |   |           |           |   |   `--NUM_INT -> 1 [10:35]
        |       |   |           |           |   |--COMMA -> , [10:36]
        |       |   |           |           |   `--EXPR -> EXPR [10:38]
        |       |   |           |           |       `--NUM_INT -> 2 [10:38]
        |       |   |           |           `--RPAREN -> ) [10:39]
        |       |   |           `--RPAREN -> ) [10:40]
        |       |   |--RPAREN -> ) [10:41]
        |       |   `--SLIST -> { [10:43]
        |       |       |--EXPR -> EXPR [11:31]
        |       |       |   `--METHOD_CALL -> ( [11:31]
        |       |       |       |--DOT -> . [11:23]
        |       |       |       |   |--DOT -> . [11:19]
        |       |       |       |   |   |--IDENT -> System [11:13]
        |       |       |       |   |   `--IDENT -> out [11:20]
        |       |       |       |   `--IDENT -> println [11:24]
        |       |       |       |--ELIST -> ELIST [11:34]
        |       |       |       |   `--EXPR -> EXPR [11:34]
        |       |       |       |       `--PLUS -> + [11:34]
        |       |       |       |           |--IDENT -> x [11:32]
        |       |       |       |           `--IDENT -> y [11:36]
        |       |       |       `--RPAREN -> ) [11:37]
        |       |       |--SEMI -> ; [11:38]
        |       |       `--RCURLY -> } [12:9]
        |       |--LITERAL_FOR -> for [14:9]
        |       |   |--LPAREN -> ( [14:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [14:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [14:14]
        |       |   |   |   |--TYPE -> TYPE [14:14]
        |       |   |   |   |   `--IDENT -> Point [14:14]
        |       |   |   |   |--LPAREN -> ( [14:19]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:20]
        |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:20]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [14:20]
        |       |   |   |   |   |   |   |--ANNOTATION -> ANNOTATION [14:20]
        |       |   |   |   |   |   |   |   |--AT -> @ [14:20]
        |       |   |   |   |   |   |   |   `--IDENT -> B [14:21]
        |       |   |   |   |   |   |   `--FINAL -> final [14:23]
        |       |   |   |   |   |   |--TYPE -> TYPE [14:29]
        |       |   |   |   |   |   |   `--IDENT -> Integer [14:29]
        |       |   |   |   |   |   `--IDENT -> x [14:37]
        |       |   |   |   |   |--COMMA -> , [14:38]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:40]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [14:40]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [14:40]
        |       |   |   |   |       |   |   |--AT -> @ [14:40]
        |       |   |   |   |       |   |   `--IDENT -> A [14:41]
        |       |   |   |   |       |   |--FINAL -> final [14:43]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [14:49]
        |       |   |   |   |       |       |--AT -> @ [14:49]
        |       |   |   |   |       |       `--IDENT -> B [14:50]
        |       |   |   |   |       |--TYPE -> TYPE [14:52]
        |       |   |   |   |       |   `--IDENT -> Integer [14:52]
        |       |   |   |   |       `--IDENT -> y [14:60]
        |       |   |   |   `--RPAREN -> ) [14:61]
        |       |   |   |--COLON -> : [15:17]
        |       |   |   `--EXPR -> EXPR [15:26]
        |       |   |       `--METHOD_CALL -> ( [15:26]
        |       |   |           |--DOT -> . [15:23]
        |       |   |           |   |--IDENT -> List [15:19]
        |       |   |           |   `--IDENT -> of [15:24]
        |       |   |           |--ELIST -> ELIST [15:27]
        |       |   |           |   `--EXPR -> EXPR [15:27]
        |       |   |           |       `--LITERAL_NEW -> new [15:27]
        |       |   |           |           |--IDENT -> Point [15:31]
        |       |   |           |           |--LPAREN -> ( [15:36]
        |       |   |           |           |--ELIST -> ELIST [15:37]
        |       |   |           |           |   |--EXPR -> EXPR [15:37]
        |       |   |           |           |   |   `--NUM_INT -> 1 [15:37]
        |       |   |           |           |   |--COMMA -> , [15:38]
        |       |   |           |           |   `--EXPR -> EXPR [15:40]
        |       |   |           |           |       `--NUM_INT -> 2 [15:40]
        |       |   |           |           `--RPAREN -> ) [15:41]
        |       |   |           `--RPAREN -> ) [15:42]
        |       |   |--RPAREN -> ) [15:43]
        |       |   `--SLIST -> { [15:45]
        |       |       |--EXPR -> EXPR [16:31]
        |       |       |   `--METHOD_CALL -> ( [16:31]
        |       |       |       |--DOT -> . [16:23]
        |       |       |       |   |--DOT -> . [16:19]
        |       |       |       |   |   |--IDENT -> System [16:13]
        |       |       |       |   |   `--IDENT -> out [16:20]
        |       |       |       |   `--IDENT -> println [16:24]
        |       |       |       |--ELIST -> ELIST [16:34]
        |       |       |       |   `--EXPR -> EXPR [16:34]
        |       |       |       |       `--PLUS -> + [16:34]
        |       |       |       |           |--IDENT -> x [16:32]
        |       |       |       |           `--IDENT -> y [16:36]
        |       |       |       `--RPAREN -> ) [16:37]
        |       |       |--SEMI -> ; [16:38]
        |       |       `--RCURLY -> } [17:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [19:9]
        |       |   |--MODIFIERS -> MODIFIERS [19:9]
        |       |   |--TYPE -> TYPE [19:9]
        |       |   |   |--IDENT -> List [19:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:13]
        |       |   |       |--GENERIC_START -> < [19:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:14]
        |       |   |       |   `--IDENT -> Points [19:14]
        |       |   |       `--GENERIC_END -> > [19:20]
        |       |   |--IDENT -> points [19:22]
        |       |   `--ASSIGN -> = [19:29]
        |       |       `--EXPR -> EXPR [20:24]
        |       |           `--METHOD_CALL -> ( [20:24]
        |       |               |--DOT -> . [20:21]
        |       |               |   |--IDENT -> List [20:17]
        |       |               |   `--IDENT -> of [20:22]
        |       |               |--ELIST -> ELIST [20:25]
        |       |               |   `--EXPR -> EXPR [20:25]
        |       |               |       `--LITERAL_NEW -> new [20:25]
        |       |               |           |--IDENT -> Points [20:29]
        |       |               |           |--LPAREN -> ( [20:35]
        |       |               |           |--ELIST -> ELIST [20:36]
        |       |               |           |   |--EXPR -> EXPR [20:36]
        |       |               |           |   |   `--LITERAL_NEW -> new [20:36]
        |       |               |           |   |       |--IDENT -> Point [20:40]
        |       |               |           |   |       |--LPAREN -> ( [20:45]
        |       |               |           |   |       |--ELIST -> ELIST [20:46]
        |       |               |           |   |       |   |--EXPR -> EXPR [20:46]
        |       |               |           |   |       |   |   `--NUM_INT -> 1 [20:46]
        |       |               |           |   |       |   |--COMMA -> , [20:47]
        |       |               |           |   |       |   `--EXPR -> EXPR [20:49]
        |       |               |           |   |       |       `--NUM_INT -> 2 [20:49]
        |       |               |           |   |       `--RPAREN -> ) [20:50]
        |       |               |           |   |--COMMA -> , [20:51]
        |       |               |           |   `--EXPR -> EXPR [20:53]
        |       |               |           |       `--LITERAL_NEW -> new [20:53]
        |       |               |           |           |--IDENT -> Point [20:57]
        |       |               |           |           |--LPAREN -> ( [20:62]
        |       |               |           |           |--ELIST -> ELIST [20:63]
        |       |               |           |           |   |--EXPR -> EXPR [20:63]
        |       |               |           |           |   |   `--NUM_INT -> 3 [20:63]
        |       |               |           |           |   |--COMMA -> , [20:64]
        |       |               |           |           |   `--EXPR -> EXPR [20:66]
        |       |               |           |           |       `--NUM_INT -> 4 [20:66]
        |       |               |           |           `--RPAREN -> ) [20:67]
        |       |               |           `--RPAREN -> ) [20:68]
        |       |               `--RPAREN -> ) [20:69]
        |       |--SEMI -> ; [20:70]
        |       |--LITERAL_FOR -> for [22:9]
        |       |   |--LPAREN -> ( [22:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [22:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [22:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [22:14]
        |       |   |   |   |--TYPE -> TYPE [22:14]
        |       |   |   |   |   `--IDENT -> Points [22:14]
        |       |   |   |   |--LPAREN -> ( [22:20]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [22:21]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:21]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [22:21]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [22:21]
        |       |   |   |   |       |       |--AT -> @ [22:21]
        |       |   |   |   |       |       `--IDENT -> A [22:22]
        |       |   |   |   |       |--TYPE -> TYPE [22:24]
        |       |   |   |   |       |   |--IDENT -> Point [22:24]
        |       |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [22:29]
        |       |   |   |   |       |       `--RBRACK -> ] [22:30]
        |       |   |   |   |       `--IDENT -> points1 [22:32]
        |       |   |   |   `--RPAREN -> ) [22:39]
        |       |   |   |--COLON -> : [22:41]
        |       |   |   `--EXPR -> EXPR [22:43]
        |       |   |       `--IDENT -> points [22:43]
        |       |   |--RPAREN -> ) [22:49]
        |       |   `--SLIST -> { [22:51]
        |       |       |--LITERAL_FOR -> for [23:13]
        |       |       |   |--LPAREN -> ( [23:17]
        |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [23:18]
        |       |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [23:18]
        |       |       |   |   |   |--MODIFIERS -> MODIFIERS [23:18]
        |       |       |   |   |   |--TYPE -> TYPE [23:18]
        |       |       |   |   |   |   `--IDENT -> Point [23:18]
        |       |       |   |   |   |--LPAREN -> ( [23:23]
        |       |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [23:24]
        |       |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [23:24]
        |       |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [23:24]
        |       |       |   |   |   |   |   |   `--FINAL -> final [23:24]
        |       |       |   |   |   |   |   |--TYPE -> TYPE [23:30]
        |       |       |   |   |   |   |   |   `--IDENT -> var [23:30]
        |       |       |   |   |   |   |   `--IDENT -> x [23:34]
        |       |       |   |   |   |   |--COMMA -> , [23:35]
        |       |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [23:37]
        |       |       |   |   |   |       |--MODIFIERS -> MODIFIERS [23:37]
        |       |       |   |   |   |       |   `--FINAL -> final [23:37]
        |       |       |   |   |   |       |--TYPE -> TYPE [23:43]
        |       |       |   |   |   |       |   `--IDENT -> var [23:43]
        |       |       |   |   |   |       `--IDENT -> y [23:47]
        |       |       |   |   |   `--RPAREN -> ) [23:48]
        |       |       |   |   |--COLON -> : [23:50]
        |       |       |   |   `--EXPR -> EXPR [23:52]
        |       |       |   |       `--IDENT -> points1 [23:52]
        |       |       |   |--RPAREN -> ) [23:59]
        |       |       |   `--SLIST -> { [23:61]
        |       |       |       |--EXPR -> EXPR [24:35]
        |       |       |       |   `--METHOD_CALL -> ( [24:35]
        |       |       |       |       |--DOT -> . [24:27]
        |       |       |       |       |   |--DOT -> . [24:23]
        |       |       |       |       |   |   |--IDENT -> System [24:17]
        |       |       |       |       |   |   `--IDENT -> out [24:24]
        |       |       |       |       |   `--IDENT -> println [24:28]
        |       |       |       |       |--ELIST -> ELIST [24:38]
        |       |       |       |       |   `--EXPR -> EXPR [24:38]
        |       |       |       |       |       `--PLUS -> + [24:38]
        |       |       |       |       |           |--IDENT -> x [24:36]
        |       |       |       |       |           `--IDENT -> y [24:40]
        |       |       |       |       `--RPAREN -> ) [24:41]
        |       |       |       |--SEMI -> ; [24:42]
        |       |       |       `--RCURLY -> } [25:13]
        |       |       `--RCURLY -> } [26:9]
        |       |--LITERAL_FOR -> for [28:9]
        |       |   |--LPAREN -> ( [28:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [28:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [28:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [28:14]
        |       |   |   |   |--TYPE -> TYPE [28:14]
        |       |   |   |   |   `--IDENT -> Points [28:14]
        |       |   |   |   |--LPAREN -> ( [28:20]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [28:21]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [28:21]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [28:21]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [28:21]
        |       |   |   |   |       |   |   |--AT -> @ [28:21]
        |       |   |   |   |       |   |   `--IDENT -> A [28:22]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [28:24]
        |       |   |   |   |       |   |   |--AT -> @ [28:24]
        |       |   |   |   |       |   |   `--IDENT -> B [28:25]
        |       |   |   |   |       |   `--FINAL -> final [28:27]
        |       |   |   |   |       |--TYPE -> TYPE [28:33]
        |       |   |   |   |       |   |--IDENT -> Point [28:33]
        |       |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [28:38]
        |       |   |   |   |       |       `--RBRACK -> ] [28:39]
        |       |   |   |   |       `--IDENT -> points1 [28:41]
        |       |   |   |   `--RPAREN -> ) [28:48]
        |       |   |   |--COLON -> : [28:50]
        |       |   |   `--EXPR -> EXPR [28:52]
        |       |   |       `--IDENT -> points [28:52]
        |       |   |--RPAREN -> ) [28:58]
        |       |   `--SLIST -> { [28:60]
        |       |       |--LITERAL_FOR -> for [29:13]
        |       |       |   |--LPAREN -> ( [29:17]
        |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [29:18]
        |       |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [29:18]
        |       |       |   |   |   |--MODIFIERS -> MODIFIERS [29:18]
        |       |       |   |   |   |--TYPE -> TYPE [29:18]
        |       |       |   |   |   |   `--IDENT -> Point [29:18]
        |       |       |   |   |   |--LPAREN -> ( [29:23]
        |       |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [29:24]
        |       |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:24]
        |       |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [29:24]
        |       |       |   |   |   |   |   |   `--FINAL -> final [29:24]
        |       |       |   |   |   |   |   |--TYPE -> TYPE [29:30]
        |       |       |   |   |   |   |   |   `--IDENT -> var [29:30]
        |       |       |   |   |   |   |   `--IDENT -> x [29:34]
        |       |       |   |   |   |   |--COMMA -> , [29:35]
        |       |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:37]
        |       |       |   |   |   |       |--MODIFIERS -> MODIFIERS [29:37]
        |       |       |   |   |   |       |   `--FINAL -> final [29:37]
        |       |       |   |   |   |       |--TYPE -> TYPE [29:43]
        |       |       |   |   |   |       |   `--IDENT -> var [29:43]
        |       |       |   |   |   |       `--IDENT -> y [29:47]
        |       |       |   |   |   `--RPAREN -> ) [29:48]
        |       |       |   |   |--COLON -> : [29:50]
        |       |       |   |   `--EXPR -> EXPR [29:52]
        |       |       |   |       `--IDENT -> points1 [29:52]
        |       |       |   |--RPAREN -> ) [29:59]
        |       |       |   `--SLIST -> { [29:61]
        |       |       |       |--EXPR -> EXPR [30:35]
        |       |       |       |   `--METHOD_CALL -> ( [30:35]
        |       |       |       |       |--DOT -> . [30:27]
        |       |       |       |       |   |--DOT -> . [30:23]
        |       |       |       |       |   |   |--IDENT -> System [30:17]
        |       |       |       |       |   |   `--IDENT -> out [30:24]
        |       |       |       |       |   `--IDENT -> println [30:28]
        |       |       |       |       |--ELIST -> ELIST [30:38]
        |       |       |       |       |   `--EXPR -> EXPR [30:38]
        |       |       |       |       |       `--PLUS -> + [30:38]
        |       |       |       |       |           |--IDENT -> x [30:36]
        |       |       |       |       |           `--IDENT -> y [30:40]
        |       |       |       |       `--RPAREN -> ) [30:41]
        |       |       |       |--SEMI -> ; [30:42]
        |       |       |       `--RCURLY -> } [31:13]
        |       |       `--RCURLY -> } [32:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [34:9]
        |       |   |--MODIFIERS -> MODIFIERS [34:9]
        |       |   |--TYPE -> TYPE [34:9]
        |       |   |   |--IDENT -> List [34:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [34:13]
        |       |   |       |--GENERIC_START -> < [34:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [34:14]
        |       |   |       |   `--IDENT -> Line [34:14]
        |       |   |       `--GENERIC_END -> > [34:18]
        |       |   |--IDENT -> lines [34:20]
        |       |   `--ASSIGN -> = [34:26]
        |       |       `--EXPR -> EXPR [35:24]
        |       |           `--METHOD_CALL -> ( [35:24]
        |       |               |--DOT -> . [35:21]
        |       |               |   |--IDENT -> List [35:17]
        |       |               |   `--IDENT -> of [35:22]
        |       |               |--ELIST -> ELIST [35:25]
        |       |               |   `--EXPR -> EXPR [35:25]
        |       |               |       `--LITERAL_NEW -> new [35:25]
        |       |               |           |--IDENT -> Line [35:29]
        |       |               |           |--LPAREN -> ( [35:33]
        |       |               |           |--ELIST -> ELIST [35:34]
        |       |               |           |   |--EXPR -> EXPR [35:34]
        |       |               |           |   |   `--LITERAL_NEW -> new [35:34]
        |       |               |           |   |       |--IDENT -> Point [35:38]
        |       |               |           |   |       |--LPAREN -> ( [35:43]
        |       |               |           |   |       |--ELIST -> ELIST [35:44]
        |       |               |           |   |       |   |--EXPR -> EXPR [35:44]
        |       |               |           |   |       |   |   `--NUM_INT -> 1 [35:44]
        |       |               |           |   |       |   |--COMMA -> , [35:45]
        |       |               |           |   |       |   `--EXPR -> EXPR [35:47]
        |       |               |           |   |       |       `--NUM_INT -> 2 [35:47]
        |       |               |           |   |       `--RPAREN -> ) [35:48]
        |       |               |           |   |--COMMA -> , [35:49]
        |       |               |           |   `--EXPR -> EXPR [35:51]
        |       |               |           |       `--LITERAL_NEW -> new [35:51]
        |       |               |           |           |--IDENT -> Point [35:55]
        |       |               |           |           |--LPAREN -> ( [35:60]
        |       |               |           |           |--ELIST -> ELIST [35:61]
        |       |               |           |           |   |--EXPR -> EXPR [35:61]
        |       |               |           |           |   |   `--NUM_INT -> 3 [35:61]
        |       |               |           |           |   |--COMMA -> , [35:62]
        |       |               |           |           |   `--EXPR -> EXPR [35:64]
        |       |               |           |           |       `--NUM_INT -> 4 [35:64]
        |       |               |           |           `--RPAREN -> ) [35:65]
        |       |               |           `--RPAREN -> ) [35:66]
        |       |               `--RPAREN -> ) [35:67]
        |       |--SEMI -> ; [35:68]
        |       |--LITERAL_FOR -> for [37:9]
        |       |   |--LPAREN -> ( [37:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [37:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [37:14]
        |       |   |   |   |--TYPE -> TYPE [37:14]
        |       |   |   |   |   `--IDENT -> Line [37:14]
        |       |   |   |   |--LPAREN -> ( [37:18]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:19]
        |       |   |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:19]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [37:19]
        |       |   |   |   |   |   |--TYPE -> TYPE [37:19]
        |       |   |   |   |   |   |   `--IDENT -> Point [37:19]
        |       |   |   |   |   |   |--LPAREN -> ( [37:24]
        |       |   |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:25]
        |       |   |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:25]
        |       |   |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [37:25]
        |       |   |   |   |   |   |   |   |   `--ANNOTATION -> ANNOTATION [37:25]
        |       |   |   |   |   |   |   |   |       |--AT -> @ [37:25]
        |       |   |   |   |   |   |   |   |       `--IDENT -> A [37:26]
        |       |   |   |   |   |   |   |   |--TYPE -> TYPE [37:28]
        |       |   |   |   |   |   |   |   |   `--IDENT -> var [37:28]
        |       |   |   |   |   |   |   |   `--IDENT -> x1 [37:32]
        |       |   |   |   |   |   |   |--COMMA -> , [37:34]
        |       |   |   |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:36]
        |       |   |   |   |   |   |       |--MODIFIERS -> MODIFIERS [37:36]
        |       |   |   |   |   |   |       |   `--ANNOTATION -> ANNOTATION [37:36]
        |       |   |   |   |   |   |       |       |--AT -> @ [37:36]
        |       |   |   |   |   |   |       |       `--IDENT -> B [37:37]
        |       |   |   |   |   |   |       |--TYPE -> TYPE [37:39]
        |       |   |   |   |   |   |       |   `--IDENT -> var [37:39]
        |       |   |   |   |   |   |       `--IDENT -> y1 [37:43]
        |       |   |   |   |   |   `--RPAREN -> ) [37:45]
        |       |   |   |   |   |--COMMA -> , [37:46]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:48]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [37:48]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [37:48]
        |       |   |   |   |       |   |   |--AT -> @ [37:48]
        |       |   |   |   |       |   |   `--IDENT -> A [37:49]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [37:51]
        |       |   |   |   |       |       |--AT -> @ [37:51]
        |       |   |   |   |       |       `--IDENT -> B [37:52]
        |       |   |   |   |       |--TYPE -> TYPE [37:54]
        |       |   |   |   |       |   `--IDENT -> Point [37:54]
        |       |   |   |   |       `--IDENT -> p2 [37:60]
        |       |   |   |   `--RPAREN -> ) [37:62]
        |       |   |   |--COLON -> : [37:64]
        |       |   |   `--EXPR -> EXPR [37:66]
        |       |   |       `--IDENT -> lines [37:66]
        |       |   |--RPAREN -> ) [37:71]
        |       |   `--SLIST -> { [37:73]
        |       |       |--EXPR -> EXPR [38:31]
        |       |       |   `--METHOD_CALL -> ( [38:31]
        |       |       |       |--DOT -> . [38:23]
        |       |       |       |   |--DOT -> . [38:19]
        |       |       |       |   |   |--IDENT -> System [38:13]
        |       |       |       |   |   `--IDENT -> out [38:20]
        |       |       |       |   `--IDENT -> println [38:24]
        |       |       |       |--ELIST -> ELIST [38:35]
        |       |       |       |   `--EXPR -> EXPR [38:35]
        |       |       |       |       `--PLUS -> + [38:35]
        |       |       |       |           |--IDENT -> x1 [38:32]
        |       |       |       |           `--IDENT -> y1 [38:37]
        |       |       |       `--RPAREN -> ) [38:39]
        |       |       |--SEMI -> ; [38:40]
        |       |       `--RCURLY -> } [39:9]
        |       |--LITERAL_FOR -> for [41:9]
        |       |   |--LPAREN -> ( [41:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [41:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [41:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [41:14]
        |       |   |   |   |--TYPE -> TYPE [41:14]
        |       |   |   |   |   `--IDENT -> Line [41:14]
        |       |   |   |   |--LPAREN -> ( [41:18]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [41:19]
        |       |   |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [41:19]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [41:19]
        |       |   |   |   |   |   |   `--ANNOTATION -> ANNOTATION [41:19]
        |       |   |   |   |   |   |       |--AT -> @ [41:19]
        |       |   |   |   |   |   |       `--IDENT -> A [41:20]
        |       |   |   |   |   |   |--TYPE -> TYPE [41:22]
        |       |   |   |   |   |   |   `--IDENT -> Point [41:22]
        |       |   |   |   |   |   |--LPAREN -> ( [41:27]
        |       |   |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [41:28]
        |       |   |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:28]
        |       |   |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [41:28]
        |       |   |   |   |   |   |   |   |   `--FINAL -> final [41:28]
        |       |   |   |   |   |   |   |   |--TYPE -> TYPE [41:34]
        |       |   |   |   |   |   |   |   |   `--IDENT -> var [41:34]
        |       |   |   |   |   |   |   |   `--IDENT -> x1 [41:38]
        |       |   |   |   |   |   |   |--COMMA -> , [41:40]
        |       |   |   |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:42]
        |       |   |   |   |   |   |       |--MODIFIERS -> MODIFIERS [41:42]
        |       |   |   |   |   |   |       |   |--ANNOTATION -> ANNOTATION [41:42]
        |       |   |   |   |   |   |       |   |   |--AT -> @ [41:42]
        |       |   |   |   |   |   |       |   |   `--IDENT -> A [41:43]
        |       |   |   |   |   |   |       |   |--ANNOTATION -> ANNOTATION [41:45]
        |       |   |   |   |   |   |       |   |   |--AT -> @ [41:45]
        |       |   |   |   |   |   |       |   |   `--IDENT -> B [41:46]
        |       |   |   |   |   |   |       |   `--FINAL -> final [41:48]
        |       |   |   |   |   |   |       |--TYPE -> TYPE [41:54]
        |       |   |   |   |   |   |       |   `--IDENT -> var [41:54]
        |       |   |   |   |   |   |       `--IDENT -> y1 [41:58]
        |       |   |   |   |   |   `--RPAREN -> ) [41:60]
        |       |   |   |   |   |--COMMA -> , [41:61]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:63]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [41:63]
        |       |   |   |   |       |   `--FINAL -> final [41:63]
        |       |   |   |   |       |--TYPE -> TYPE [41:69]
        |       |   |   |   |       |   `--IDENT -> Point [41:69]
        |       |   |   |   |       `--IDENT -> p2 [41:75]
        |       |   |   |   `--RPAREN -> ) [41:77]
        |       |   |   |--COLON -> : [42:17]
        |       |   |   `--EXPR -> EXPR [42:19]
        |       |   |       `--IDENT -> lines [42:19]
        |       |   |--RPAREN -> ) [42:24]
        |       |   `--SLIST -> { [42:26]
        |       |       |--EXPR -> EXPR [43:31]
        |       |       |   `--METHOD_CALL -> ( [43:31]
        |       |       |       |--DOT -> . [43:23]
        |       |       |       |   |--DOT -> . [43:19]
        |       |       |       |   |   |--IDENT -> System [43:13]
        |       |       |       |   |   `--IDENT -> out [43:20]
        |       |       |       |   `--IDENT -> println [43:24]
        |       |       |       |--ELIST -> ELIST [43:35]
        |       |       |       |   `--EXPR -> EXPR [43:35]
        |       |       |       |       `--PLUS -> + [43:35]
        |       |       |       |           |--IDENT -> x1 [43:32]
        |       |       |       |           `--IDENT -> y1 [43:37]
        |       |       |       `--RPAREN -> ) [43:39]
        |       |       |--SEMI -> ; [43:40]
        |       |       `--RCURLY -> } [44:9]
        |       |--LITERAL_FOR -> for [46:9]
        |       |   |--LPAREN -> ( [46:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [46:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [46:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [46:14]
        |       |   |   |   |--TYPE -> TYPE [46:14]
        |       |   |   |   |   `--IDENT -> Points [46:14]
        |       |   |   |   |--LPAREN -> ( [46:20]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [46:21]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:21]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [46:21]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [46:21]
        |       |   |   |   |       |       |--AT -> @ [46:21]
        |       |   |   |   |       |       `--IDENT -> A [46:22]
        |       |   |   |   |       |--TYPE -> TYPE [46:24]
        |       |   |   |   |       |   |--IDENT -> Point [46:24]
        |       |   |   |   |       |   |--ANNOTATIONS -> ANNOTATIONS [46:30]
        |       |   |   |   |       |   |   `--ANNOTATION -> ANNOTATION [46:30]
        |       |   |   |   |       |   |       |--AT -> @ [46:30]
        |       |   |   |   |       |   |       `--IDENT -> B [46:31]
        |       |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [46:33]
        |       |   |   |   |       |       `--RBRACK -> ] [46:34]
        |       |   |   |   |       `--IDENT -> points1 [46:36]
        |       |   |   |   `--RPAREN -> ) [46:43]
        |       |   |   |--COLON -> : [46:45]
        |       |   |   `--EXPR -> EXPR [46:47]
        |       |   |       `--IDENT -> points [46:47]
        |       |   |--RPAREN -> ) [46:53]
        |       |   `--SLIST -> { [46:55]
        |       |       |--EXPR -> EXPR [47:31]
        |       |       |   `--METHOD_CALL -> ( [47:31]
        |       |       |       |--DOT -> . [47:23]
        |       |       |       |   |--DOT -> . [47:19]
        |       |       |       |   |   |--IDENT -> System [47:13]
        |       |       |       |   |   `--IDENT -> out [47:20]
        |       |       |       |   `--IDENT -> println [47:24]
        |       |       |       |--ELIST -> ELIST [47:39]
        |       |       |       |   `--EXPR -> EXPR [47:39]
        |       |       |       |       `--DOT -> . [47:39]
        |       |       |       |           |--IDENT -> points1 [47:32]
        |       |       |       |           `--IDENT -> length [47:40]
        |       |       |       `--RPAREN -> ) [47:46]
        |       |       |--SEMI -> ; [47:47]
        |       |       `--RCURLY -> } [48:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [50:9]
        |       |   |--MODIFIERS -> MODIFIERS [50:9]
        |       |   |--TYPE -> TYPE [50:9]
        |       |   |   |--IDENT -> List [50:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:13]
        |       |   |       |--GENERIC_START -> < [50:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:14]
        |       |   |       |   |--IDENT -> Box [50:14]
        |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:17]
        |       |   |       |       |--GENERIC_START -> < [50:17]
        |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:18]
        |       |   |       |       |   `--IDENT -> Integer [50:18]
        |       |   |       |       `--GENERIC_END -> > [50:25]
        |       |   |       `--GENERIC_END -> > [50:26]
        |       |   |--IDENT -> boxes [50:28]
        |       |   `--ASSIGN -> = [50:34]
        |       |       `--EXPR -> EXPR [50:43]
        |       |           `--METHOD_CALL -> ( [50:43]
        |       |               |--DOT -> . [50:40]
        |       |               |   |--IDENT -> List [50:36]
        |       |               |   `--IDENT -> of [50:41]
        |       |               |--ELIST -> ELIST [50:44]
        |       |               |   `--EXPR -> EXPR [50:44]
        |       |               |       `--LITERAL_NEW -> new [50:44]
        |       |               |           |--IDENT -> Box [50:48]
        |       |               |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:51]
        |       |               |           |   |--GENERIC_START -> < [50:51]
        |       |               |           |   `--GENERIC_END -> > [50:52]
        |       |               |           |--LPAREN -> ( [50:53]
        |       |               |           |--ELIST -> ELIST [50:54]
        |       |               |           |   `--EXPR -> EXPR [50:54]
        |       |               |           |       `--NUM_INT -> 1 [50:54]
        |       |               |           `--RPAREN -> ) [50:55]
        |       |               `--RPAREN -> ) [50:56]
        |       |--SEMI -> ; [50:57]
        |       |--LITERAL_FOR -> for [52:9]
        |       |   |--LPAREN -> ( [52:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [52:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [52:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [52:14]
        |       |   |   |   |--TYPE -> TYPE [52:14]
        |       |   |   |   |   |--IDENT -> Box [52:14]
        |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [52:17]
        |       |   |   |   |       |--GENERIC_START -> < [52:17]
        |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [52:18]
        |       |   |   |   |       |   `--IDENT -> Integer [52:18]
        |       |   |   |   |       `--GENERIC_END -> > [52:25]
        |       |   |   |   |--LPAREN -> ( [52:26]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [52:27]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:27]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [52:27]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [52:27]
        |       |   |   |   |       |       |--AT -> @ [52:27]
        |       |   |   |   |       |       |--IDENT -> C [52:28]
        |       |   |   |   |       |       |--LPAREN -> ( [52:29]
        |       |   |   |   |       |       |--EXPR -> EXPR [52:30]
        |       |   |   |   |       |       |   `--NUM_INT -> 1 [52:30]
        |       |   |   |   |       |       `--RPAREN -> ) [52:31]
        |       |   |   |   |       |--TYPE -> TYPE [52:33]
        |       |   |   |   |       |   `--IDENT -> Integer [52:33]
        |       |   |   |   |       `--IDENT -> i [52:41]
        |       |   |   |   `--RPAREN -> ) [52:42]
        |       |   |   |--COLON -> : [52:44]
        |       |   |   `--EXPR -> EXPR [52:46]
        |       |   |       `--IDENT -> boxes [52:46]
        |       |   |--RPAREN -> ) [52:51]
        |       |   `--SLIST -> { [52:53]
        |       |       |--EXPR -> EXPR [53:31]
        |       |       |   `--METHOD_CALL -> ( [53:31]
        |       |       |       |--DOT -> . [53:23]
        |       |       |       |   |--DOT -> . [53:19]
        |       |       |       |   |   |--IDENT -> System [53:13]
        |       |       |       |   |   `--IDENT -> out [53:20]
        |       |       |       |   `--IDENT -> println [53:24]
        |       |       |       |--ELIST -> ELIST [53:32]
        |       |       |       |   `--EXPR -> EXPR [53:32]
        |       |       |       |       `--IDENT -> i [53:32]
        |       |       |       `--RPAREN -> ) [53:33]
        |       |       |--SEMI -> ; [53:34]
        |       |       `--RCURLY -> } [54:9]
        |       |--LITERAL_FOR -> for [56:9]
        |       |   |--LPAREN -> ( [56:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [56:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [56:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [56:14]
        |       |   |   |   |--TYPE -> TYPE [56:14]
        |       |   |   |   |   |--IDENT -> Box [56:14]
        |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:17]
        |       |   |   |   |       |--GENERIC_START -> < [56:17]
        |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:18]
        |       |   |   |   |       |   |--ANNOTATIONS -> ANNOTATIONS [56:18]
        |       |   |   |   |       |   |   `--ANNOTATION -> ANNOTATION [56:18]
        |       |   |   |   |       |   |       |--AT -> @ [56:18]
        |       |   |   |   |       |   |       `--IDENT -> A [56:19]
        |       |   |   |   |       |   `--IDENT -> Integer [56:21]
        |       |   |   |   |       `--GENERIC_END -> > [56:28]
        |       |   |   |   |--LPAREN -> ( [56:29]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [56:30]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:30]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [56:30]
        |       |   |   |   |       |   |--ANNOTATION -> ANNOTATION [56:30]
        |       |   |   |   |       |   |   |--AT -> @ [56:30]
        |       |   |   |   |       |   |   |--IDENT -> C [56:31]
        |       |   |   |   |       |   |   |--LPAREN -> ( [56:32]
        |       |   |   |   |       |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [56:33]
        |       |   |   |   |       |   |   |   |--IDENT -> value [56:33]
        |       |   |   |   |       |   |   |   |--ASSIGN -> = [56:39]
        |       |   |   |   |       |   |   |   `--EXPR -> EXPR [56:41]
        |       |   |   |   |       |   |   |       `--NUM_INT -> 2 [56:41]
        |       |   |   |   |       |   |   `--RPAREN -> ) [56:42]
        |       |   |   |   |       |   `--FINAL -> final [56:44]
        |       |   |   |   |       |--TYPE -> TYPE [56:50]
        |       |   |   |   |       |   `--IDENT -> var [56:50]
        |       |   |   |   |       `--IDENT -> i [56:54]
        |       |   |   |   `--RPAREN -> ) [56:55]
        |       |   |   |--COLON -> : [56:57]
        |       |   |   `--EXPR -> EXPR [56:59]
        |       |   |       `--IDENT -> boxes [56:59]
        |       |   |--RPAREN -> ) [56:64]
        |       |   `--SLIST -> { [56:66]
        |       |       |--EXPR -> EXPR [57:31]
        |       |       |   `--METHOD_CALL -> ( [57:31]
        |       |       |       |--DOT -> . [57:23]
        |       |       |       |   |--DOT -> . [57:19]
        |       |       |       |   |   |--IDENT -> System [57:13]
        |       |       |       |   |   `--IDENT -> out [57:20]
        |       |       |       |   `--IDENT -> println [57:24]
        |       |       |       |--ELIST -> ELIST [57:32]
        |       |       |       |   `--EXPR -> EXPR [57:32]
        |       |       |       |       `--IDENT -> i [57:32]
        |       |       |       `--RPAREN -> ) [57:33]
        |       |       |--SEMI -> ; [57:34]
        |       |       `--RCURLY -> } [58:9]
        |       |--LITERAL_FOR -> for [60:9]
        |       |   |--LPAREN -> ( [60:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [60:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [60:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [60:14]
        |       |   |   |   |--TYPE -> TYPE [60:14]
        |       |   |   |   |   |--IDENT -> Box [60:14]
        |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [60:17]
        |       |   |   |   |       |--GENERIC_START -> < [60:17]
        |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [60:18]
        |       |   |   |   |       |   `--IDENT -> Integer [60:18]
        |       |   |   |   |       `--GENERIC_END -> > [60:25]
        |       |   |   |   |--LPAREN -> ( [60:26]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [61:17]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:17]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [61:17]
        |       |   |   |   |       |   `--ANNOTATION -> ANNOTATION [61:17]
        |       |   |   |   |       |       |--AT -> @ [61:17]
        |       |   |   |   |       |       `--DOT -> . [61:69]
        |       |   |   |   |       |           |--IDENT -> InputJava20RecordDecompositionEnhancedForLoopTricky [61:18]
        |       |   |   |   |       |           `--IDENT -> A [61:70]
        |       |   |   |   |       |--TYPE -> TYPE [61:72]
        |       |   |   |   |       |   `--IDENT -> Integer [61:72]
        |       |   |   |   |       `--IDENT -> i [61:80]
        |       |   |   |   `--RPAREN -> ) [61:81]
        |       |   |   |--COLON -> : [62:17]
        |       |   |   `--EXPR -> EXPR [62:19]
        |       |   |       `--IDENT -> boxes [62:19]
        |       |   |--RPAREN -> ) [62:24]
        |       |   `--SLIST -> { [62:26]
        |       |       |--EXPR -> EXPR [63:31]
        |       |       |   `--METHOD_CALL -> ( [63:31]
        |       |       |       |--DOT -> . [63:23]
        |       |       |       |   |--DOT -> . [63:19]
        |       |       |       |   |   |--IDENT -> System [63:13]
        |       |       |       |   |   `--IDENT -> out [63:20]
        |       |       |       |   `--IDENT -> println [63:24]
        |       |       |       |--ELIST -> ELIST [63:32]
        |       |       |       |   `--EXPR -> EXPR [63:32]
        |       |       |       |       `--IDENT -> i [63:32]
        |       |       |       `--RPAREN -> ) [63:33]
        |       |       |--SEMI -> ; [63:34]
        |       |       `--RCURLY -> } [64:9]
        |       `--RCURLY -> } [65:5]
        |--RECORD_DEF -> RECORD_DEF [67:5]
        |   |--MODIFIERS -> MODIFIERS [67:5]
        |   |--LITERAL_RECORD -> record [67:5]
        |   |--IDENT -> Point [67:12]
        |   |--LPAREN -> ( [67:17]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [67:18]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [67:18]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [67:18]
        |   |   |   |   `--ANNOTATION -> ANNOTATION [67:18]
        |   |   |   |       |--AT -> @ [67:18]
        |   |   |   |       `--IDENT -> A [67:19]
        |   |   |   |--TYPE -> TYPE [67:21]
        |   |   |   |   `--IDENT -> Integer [67:21]
        |   |   |   `--IDENT -> x [67:29]
        |   |   |--COMMA -> , [67:30]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [67:32]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [67:32]
        |   |       |--TYPE -> TYPE [67:32]
        |   |       |   `--IDENT -> Integer [67:32]
        |   |       `--IDENT -> y [67:40]
        |   |--RPAREN -> ) [67:41]
        |   `--OBJBLOCK -> OBJBLOCK [67:43]
        |       |--LCURLY -> { [67:43]
        |       `--RCURLY -> } [67:45]
        |--RECORD_DEF -> RECORD_DEF [68:5]
        |   |--MODIFIERS -> MODIFIERS [68:5]
        |   |--LITERAL_RECORD -> record [68:5]
        |   |--IDENT -> Points [68:12]
        |   |--LPAREN -> ( [68:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [68:19]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [68:19]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [68:19]
        |   |       |--TYPE -> TYPE [68:19]
        |   |       |   `--IDENT -> Point [68:19]
        |   |       |--ELLIPSIS -> ... [68:24]
        |   |       `--IDENT -> points [68:28]
        |   |--RPAREN -> ) [68:34]
        |   `--OBJBLOCK -> OBJBLOCK [68:36]
        |       |--LCURLY -> { [68:36]
        |       `--RCURLY -> } [68:38]
        |--RECORD_DEF -> RECORD_DEF [69:5]
        |   |--MODIFIERS -> MODIFIERS [69:5]
        |   |--LITERAL_RECORD -> record [69:5]
        |   |--IDENT -> Line [69:12]
        |   |--LPAREN -> ( [69:16]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [69:17]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [69:17]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [69:17]
        |   |   |   |--TYPE -> TYPE [69:17]
        |   |   |   |   `--IDENT -> Point [69:17]
        |   |   |   `--IDENT -> p1 [69:23]
        |   |   |--COMMA -> , [69:25]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [69:27]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [69:27]
        |   |       |--TYPE -> TYPE [69:27]
        |   |       |   `--IDENT -> Point [69:27]
        |   |       `--IDENT -> p2 [69:33]
        |   |--RPAREN -> ) [69:35]
        |   `--OBJBLOCK -> OBJBLOCK [69:37]
        |       |--LCURLY -> { [69:37]
        |       `--RCURLY -> } [69:39]
        |--RECORD_DEF -> RECORD_DEF [70:5]
        |   |--MODIFIERS -> MODIFIERS [70:5]
        |   |--LITERAL_RECORD -> record [70:5]
        |   |--IDENT -> Box [70:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [70:15]
        |   |   |--GENERIC_START -> < [70:15]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [70:16]
        |   |   |   `--IDENT -> T [70:16]
        |   |   `--GENERIC_END -> > [70:17]
        |   |--LPAREN -> ( [70:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [70:19]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [70:19]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [70:19]
        |   |       |--TYPE -> TYPE [70:19]
        |   |       |   `--IDENT -> T [70:19]
        |   |       `--IDENT -> t [70:21]
        |   |--RPAREN -> ) [70:22]
        |   `--OBJBLOCK -> OBJBLOCK [70:24]
        |       |--LCURLY -> { [70:24]
        |       `--RCURLY -> } [70:26]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [71:5]
        |   |--MODIFIERS -> MODIFIERS [71:5]
        |   |--AT -> @ [71:5]
        |   |--LITERAL_INTERFACE -> interface [71:7]
        |   |--IDENT -> A [71:17]
        |   `--OBJBLOCK -> OBJBLOCK [71:19]
        |       |--LCURLY -> { [71:19]
        |       `--RCURLY -> } [71:20]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [72:5]
        |   |--MODIFIERS -> MODIFIERS [72:5]
        |   |--AT -> @ [72:5]
        |   |--LITERAL_INTERFACE -> interface [72:7]
        |   |--IDENT -> B [72:17]
        |   `--OBJBLOCK -> OBJBLOCK [72:19]
        |       |--LCURLY -> { [72:19]
        |       `--RCURLY -> } [72:20]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [73:5]
        |   |--MODIFIERS -> MODIFIERS [73:5]
        |   |--AT -> @ [73:5]
        |   |--LITERAL_INTERFACE -> interface [73:7]
        |   |--IDENT -> C [73:17]
        |   `--OBJBLOCK -> OBJBLOCK [73:19]
        |       |--LCURLY -> { [73:19]
        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [73:21]
        |       |   |--MODIFIERS -> MODIFIERS [73:21]
        |       |   |--TYPE -> TYPE [73:21]
        |       |   |   `--LITERAL_INT -> int [73:21]
        |       |   |--IDENT -> value [73:25]
        |       |   |--LPAREN -> ( [73:30]
        |       |   |--RPAREN -> ) [73:31]
        |       |   `--SEMI -> ; [73:32]
        |       `--RCURLY -> } [73:34]
        `--RCURLY -> } [74:1]
