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 -> java19 [2:49]
|   `--SEMI -> ; [2:55]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> Iterator [4:18]
|   `--SEMI -> ; [4:26]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:17]
|   |   |--DOT -> . [5:12]
|   |   |   |--IDENT -> java [5:8]
|   |   |   `--IDENT -> util [5:13]
|   |   `--IDENT -> List [5:18]
|   `--SEMI -> ; [5:22]
`--CLASS_DEF -> CLASS_DEF [7:1]
    |--MODIFIERS -> MODIFIERS [7:1]
    |   `--LITERAL_PUBLIC -> public [7:1]
    |--LITERAL_CLASS -> class [7:8]
    |--IDENT -> InputJava19RecordDecompositionWithConditionInLoops [7:14]
    `--OBJBLOCK -> OBJBLOCK [7:65]
        |--LCURLY -> { [7:65]
        |--RECORD_DEF -> RECORD_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |--LITERAL_RECORD -> record [8:5]
        |   |--IDENT -> R [8:12]
        |   |--LPAREN -> ( [8:13]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:14]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:14]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:14]
        |   |       |--TYPE -> TYPE [8:14]
        |   |       |   `--IDENT -> R [8:14]
        |   |       `--IDENT -> r [8:16]
        |   |--RPAREN -> ) [8:17]
        |   `--OBJBLOCK -> OBJBLOCK [8:19]
        |       |--LCURLY -> { [8:19]
        |       `--RCURLY -> } [10:5]
        |--METHOD_DEF -> METHOD_DEF [12:5]
        |   |--MODIFIERS -> MODIFIERS [12:5]
        |   |   |--LITERAL_PUBLIC -> public [12:5]
        |   |   `--LITERAL_STATIC -> static [12:12]
        |   |--TYPE -> TYPE [12:19]
        |   |   `--LITERAL_VOID -> void [12:19]
        |   |--IDENT -> main [12:24]
        |   |--LPAREN -> ( [12:28]
        |   |--PARAMETERS -> PARAMETERS [12:29]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:29]
        |   |       |--MODIFIERS -> MODIFIERS [12:29]
        |   |       |--TYPE -> TYPE [12:29]
        |   |       |   `--IDENT -> String [12:29]
        |   |       |--ELLIPSIS -> ... [12:35]
        |   |       `--IDENT -> args [12:39]
        |   |--RPAREN -> ) [12:43]
        |   `--SLIST -> { [12:45]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [13:9]
        |       |   |--MODIFIERS -> MODIFIERS [13:9]
        |       |   |--TYPE -> TYPE [13:9]
        |       |   |   `--IDENT -> R [13:9]
        |       |   |--IDENT -> r [13:11]
        |       |   `--ASSIGN -> = [13:13]
        |       |       `--EXPR -> EXPR [13:15]
        |       |           `--LITERAL_NEW -> new [13:15]
        |       |               |--IDENT -> R [13:19]
        |       |               |--LPAREN -> ( [13:20]
        |       |               |--ELIST -> ELIST [13:21]
        |       |               |   `--EXPR -> EXPR [13:21]
        |       |               |       `--LITERAL_NEW -> new [13:21]
        |       |               |           |--IDENT -> R [13:25]
        |       |               |           |--LPAREN -> ( [13:26]
        |       |               |           |--ELIST -> ELIST [13:27]
        |       |               |           |   `--EXPR -> EXPR [13:27]
        |       |               |           |       `--LITERAL_NULL -> null [13:27]
        |       |               |           `--RPAREN -> ) [13:31]
        |       |               `--RPAREN -> ) [13:32]
        |       |--SEMI -> ; [13:33]
        |       |--LITERAL_IF -> if [14:9]
        |       |   |--LPAREN -> ( [14:12]
        |       |   |--EXPR -> EXPR [14:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [14:15]
        |       |   |       |--IDENT -> r [14:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [14:26]
        |       |   |           |--TYPE -> TYPE [14:26]
        |       |   |           |   `--IDENT -> R [14:26]
        |       |   |           |--LPAREN -> ( [14:27]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:28]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:28]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [14:28]
        |       |   |           |       |--TYPE -> TYPE [14:28]
        |       |   |           |       |   `--IDENT -> R [14:28]
        |       |   |           |       `--IDENT -> recordComponent [14:30]
        |       |   |           |--RPAREN -> ) [14:45]
        |       |   |           `--IDENT -> r1 [14:47]
        |       |   |--RPAREN -> ) [14:49]
        |       |   |--SLIST -> { [14:51]
        |       |   |   |--EXPR -> EXPR [15:31]
        |       |   |   |   `--METHOD_CALL -> ( [15:31]
        |       |   |   |       |--DOT -> . [15:23]
        |       |   |   |       |   |--DOT -> . [15:19]
        |       |   |   |       |   |   |--IDENT -> System [15:13]
        |       |   |   |       |   |   `--IDENT -> out [15:20]
        |       |   |   |       |   `--IDENT -> println [15:24]
        |       |   |   |       |--ELIST -> ELIST [15:32]
        |       |   |   |       |   `--EXPR -> EXPR [15:32]
        |       |   |   |       |       `--IDENT -> recordComponent [15:32]
        |       |   |   |       `--RPAREN -> ) [15:47]
        |       |   |   |--SEMI -> ; [15:48]
        |       |   |   `--RCURLY -> } [16:9]
        |       |   `--LITERAL_ELSE -> else [16:11]
        |       |       `--LITERAL_IF -> if [16:16]
        |       |           |--LPAREN -> ( [16:19]
        |       |           |--EXPR -> EXPR [16:22]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [16:22]
        |       |           |       |--IDENT -> r [16:20]
        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:33]
        |       |           |           |--MODIFIERS -> MODIFIERS [16:33]
        |       |           |           |--TYPE -> TYPE [16:33]
        |       |           |           |   `--IDENT -> R [16:33]
        |       |           |           |--LPAREN -> ( [16:34]
        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:35]
        |       |           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:35]
        |       |           |           |       |--MODIFIERS -> MODIFIERS [16:35]
        |       |           |           |       |--TYPE -> TYPE [16:35]
        |       |           |           |       |   `--IDENT -> R [16:35]
        |       |           |           |       |--LPAREN -> ( [16:36]
        |       |           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:37]
        |       |           |           |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [16:37]
        |       |           |           |       |       |--MODIFIERS -> MODIFIERS [16:37]
        |       |           |           |       |       |--TYPE -> TYPE [16:37]
        |       |           |           |       |       |   `--IDENT -> R [16:37]
        |       |           |           |       |       `--IDENT -> innerRecordComponent [16:39]
        |       |           |           |       |--RPAREN -> ) [16:59]
        |       |           |           |       `--IDENT -> r2 [16:61]
        |       |           |           |--RPAREN -> ) [16:63]
        |       |           |           `--IDENT -> r3 [16:65]
        |       |           |--RPAREN -> ) [16:67]
        |       |           |--SLIST -> { [16:69]
        |       |           |   |--EXPR -> EXPR [17:31]
        |       |           |   |   `--METHOD_CALL -> ( [17:31]
        |       |           |   |       |--DOT -> . [17:23]
        |       |           |   |       |   |--DOT -> . [17:19]
        |       |           |   |       |   |   |--IDENT -> System [17:13]
        |       |           |   |       |   |   `--IDENT -> out [17:20]
        |       |           |   |       |   `--IDENT -> println [17:24]
        |       |           |   |       |--ELIST -> ELIST [17:32]
        |       |           |   |       |   `--EXPR -> EXPR [17:32]
        |       |           |   |       |       `--IDENT -> innerRecordComponent [17:32]
        |       |           |   |       `--RPAREN -> ) [17:52]
        |       |           |   |--SEMI -> ; [17:53]
        |       |           |   `--RCURLY -> } [18:9]
        |       |           `--LITERAL_ELSE -> else [18:11]
        |       |               `--LITERAL_IF -> if [18:16]
        |       |                   |--LPAREN -> ( [18:19]
        |       |                   |--EXPR -> EXPR [18:22]
        |       |                   |   `--LITERAL_INSTANCEOF -> instanceof [18:22]
        |       |                   |       |--IDENT -> r [18:20]
        |       |                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:33]
        |       |                   |           |--MODIFIERS -> MODIFIERS [18:33]
        |       |                   |           |--TYPE -> TYPE [18:33]
        |       |                   |           |   `--IDENT -> R [18:33]
        |       |                   |           |--LPAREN -> ( [18:34]
        |       |                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:35]
        |       |                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:35]
        |       |                   |           |       |--MODIFIERS -> MODIFIERS [18:35]
        |       |                   |           |       |--TYPE -> TYPE [18:35]
        |       |                   |           |       |   `--IDENT -> R [18:35]
        |       |                   |           |       |--LPAREN -> ( [18:36]
        |       |                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:37]
        |       |                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:37]
        |       |                   |           |       |       |--MODIFIERS -> MODIFIERS [18:37]
        |       |                   |           |       |       |--TYPE -> TYPE [18:37]
        |       |                   |           |       |       |   `--IDENT -> R [18:37]
        |       |                   |           |       |       |--LPAREN -> ( [18:38]
        |       |                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:39]
        |       |                   |           |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [18:39]
        |       |                   |           |       |       |       |--MODIFIERS -> MODIFIERS [18:39]
        |       |                   |           |       |       |       |--TYPE -> TYPE [18:39]
        |       |                   |           |       |       |       |   `--IDENT -> R [18:39]
        |       |                   |           |       |       |       `--IDENT -> innerInnerRecordComponent [18:41]
        |       |                   |           |       |       `--RPAREN -> ) [18:66]
        |       |                   |           |       `--RPAREN -> ) [18:67]
        |       |                   |           `--RPAREN -> ) [18:68]
        |       |                   |--RPAREN -> ) [18:69]
        |       |                   |--SLIST -> { [18:71]
        |       |                   |   |--EXPR -> EXPR [19:31]
        |       |                   |   |   `--METHOD_CALL -> ( [19:31]
        |       |                   |   |       |--DOT -> . [19:23]
        |       |                   |   |       |   |--DOT -> . [19:19]
        |       |                   |   |       |   |   |--IDENT -> System [19:13]
        |       |                   |   |       |   |   `--IDENT -> out [19:20]
        |       |                   |   |       |   `--IDENT -> println [19:24]
        |       |                   |   |       |--ELIST -> ELIST [19:32]
        |       |                   |   |       |   `--EXPR -> EXPR [19:32]
        |       |                   |   |       |       `--IDENT -> innerInnerRecordComponent [19:32]
        |       |                   |   |       `--RPAREN -> ) [19:57]
        |       |                   |   |--SEMI -> ; [19:58]
        |       |                   |   `--RCURLY -> } [20:9]
        |       |                   `--LITERAL_ELSE -> else [20:11]
        |       |                       `--LITERAL_IF -> if [20:16]
        |       |                           |--LPAREN -> ( [20:19]
        |       |                           |--EXPR -> EXPR [20:22]
        |       |                           |   `--LITERAL_INSTANCEOF -> instanceof [20:22]
        |       |                           |       |--IDENT -> r [20:20]
        |       |                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:17]
        |       |                           |           |--MODIFIERS -> MODIFIERS [21:17]
        |       |                           |           |--TYPE -> TYPE [21:17]
        |       |                           |           |   `--IDENT -> R [21:17]
        |       |                           |           |--LPAREN -> ( [21:18]
        |       |                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:19]
        |       |                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:19]
        |       |                           |           |       |--MODIFIERS -> MODIFIERS [21:19]
        |       |                           |           |       |--TYPE -> TYPE [21:19]
        |       |                           |           |       |   `--IDENT -> R [21:19]
        |       |                           |           |       |--LPAREN -> ( [21:20]
        |       |                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:21]
        |       |                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:21]
        |       |                           |           |       |       |--MODIFIERS -> MODIFIERS [21:21]
        |       |                           |           |       |       |--TYPE -> TYPE [21:21]
        |       |                           |           |       |       |   `--IDENT -> R [21:21]
        |       |                           |           |       |       |--LPAREN -> ( [21:22]
        |       |                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:23]
        |       |                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:23]
        |       |                           |           |       |       |       |--MODIFIERS -> MODIFIERS [21:23]
        |       |                           |           |       |       |       |--TYPE -> TYPE [21:23]
        |       |                           |           |       |       |       |   `--IDENT -> R [21:23]
        |       |                           |           |       |       |       |--LPAREN -> ( [21:24]
        |       |                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:25]
        |       |                           |           |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:25]
        |       |                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [21:25]
        |       |                           |           |       |       |       |       |--TYPE -> TYPE [21:25]
        |       |                           |           |       |       |       |       |   `--IDENT -> R [21:25]
        |       |                           |           |       |       |       |       `--IDENT -> innerInnerInnerRecordComponent [21:27]
        |       |                           |           |       |       |       `--RPAREN -> ) [21:57]
        |       |                           |           |       |       `--RPAREN -> ) [21:58]
        |       |                           |           |       `--RPAREN -> ) [21:59]
        |       |                           |           `--RPAREN -> ) [21:60]
        |       |                           |--RPAREN -> ) [21:61]
        |       |                           |--SLIST -> { [21:63]
        |       |                           |   |--EXPR -> EXPR [22:31]
        |       |                           |   |   `--METHOD_CALL -> ( [22:31]
        |       |                           |   |       |--DOT -> . [22:23]
        |       |                           |   |       |   |--DOT -> . [22:19]
        |       |                           |   |       |   |   |--IDENT -> System [22:13]
        |       |                           |   |       |   |   `--IDENT -> out [22:20]
        |       |                           |   |       |   `--IDENT -> println [22:24]
        |       |                           |   |       |--ELIST -> ELIST [22:32]
        |       |                           |   |       |   `--EXPR -> EXPR [22:32]
        |       |                           |   |       |       `--IDENT -> innerInnerInnerRecordComponent [22:32]
        |       |                           |   |       `--RPAREN -> ) [22:62]
        |       |                           |   |--SEMI -> ; [22:63]
        |       |                           |   `--RCURLY -> } [23:9]
        |       |                           `--LITERAL_ELSE -> else [23:11]
        |       |                               `--LITERAL_IF -> if [23:16]
        |       |                                   |--LPAREN -> ( [23:19]
        |       |                                   |--EXPR -> EXPR [23:22]
        |       |                                   |   `--LITERAL_INSTANCEOF -> instanceof [23:22]
        |       |                                   |       |--IDENT -> r [23:20]
        |       |                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:17]
        |       |                                   |           |--MODIFIERS -> MODIFIERS [24:17]
        |       |                                   |           |--TYPE -> TYPE [24:17]
        |       |                                   |           |   `--IDENT -> R [24:17]
        |       |                                   |           |--LPAREN -> ( [24:18]
        |       |                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:19]
        |       |                                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:19]
        |       |                                   |           |       |--MODIFIERS -> MODIFIERS [24:19]
        |       |                                   |           |       |--TYPE -> TYPE [24:19]
        |       |                                   |           |       |   `--IDENT -> R [24:19]
        |       |                                   |           |       |--LPAREN -> ( [24:20]
        |       |                                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:21]
        |       |                                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:21]
        |       |                                   |           |       |       |--MODIFIERS -> MODIFIERS [24:21]
        |       |                                   |           |       |       |--TYPE -> TYPE [24:21]
        |       |                                   |           |       |       |   `--IDENT -> R [24:21]
        |       |                                   |           |       |       |--LPAREN -> ( [24:22]
        |       |                                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:23]
        |       |                                   |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:23]
        |       |                                   |           |       |       |       |--MODIFIERS -> MODIFIERS [24:23]
        |       |                                   |           |       |       |       |--TYPE -> TYPE [24:23]
        |       |                                   |           |       |       |       |   `--IDENT -> R [24:23]
        |       |                                   |           |       |       |       |--LPAREN -> ( [24:24]
        |       |                                   |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:25]
        |       |                                   |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:25]
        |       |                                   |           |       |       |       |       |--MODIFIERS -> MODIFIERS [24:25]
        |       |                                   |           |       |       |       |       |--TYPE -> TYPE [24:25]
        |       |                                   |           |       |       |       |       |   `--IDENT -> R [24:25]
        |       |                                   |           |       |       |       |       |--LPAREN -> ( [24:26]
        |       |                                   |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:27]
        |       |                                   |           |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:27]
        |       |                                   |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [24:27]
        |       |                                   |           |       |       |       |       |       |--TYPE -> TYPE [24:27]
        |       |                                   |           |       |       |       |       |       |   `--IDENT -> R [24:27]
        |       |                                   |           |       |       |       |       |       `--IDENT -> innerInnerInnerInnerRecordComponent [24:29]
        |       |                                   |           |       |       |       |       `--RPAREN -> ) [24:64]
        |       |                                   |           |       |       |       `--RPAREN -> ) [24:65]
        |       |                                   |           |       |       `--RPAREN -> ) [24:66]
        |       |                                   |           |       `--RPAREN -> ) [24:67]
        |       |                                   |           `--RPAREN -> ) [24:68]
        |       |                                   |--RPAREN -> ) [24:69]
        |       |                                   |--SLIST -> { [24:71]
        |       |                                   |   |--EXPR -> EXPR [25:31]
        |       |                                   |   |   `--METHOD_CALL -> ( [25:31]
        |       |                                   |   |       |--DOT -> . [25:23]
        |       |                                   |   |       |   |--DOT -> . [25:19]
        |       |                                   |   |       |   |   |--IDENT -> System [25:13]
        |       |                                   |   |       |   |   `--IDENT -> out [25:20]
        |       |                                   |   |       |   `--IDENT -> println [25:24]
        |       |                                   |   |       |--ELIST -> ELIST [25:32]
        |       |                                   |   |       |   `--EXPR -> EXPR [25:32]
        |       |                                   |   |       |       `--IDENT -> innerInnerInnerInnerRecordComponent [25:32]
        |       |                                   |   |       `--RPAREN -> ) [25:67]
        |       |                                   |   |--SEMI -> ; [25:68]
        |       |                                   |   `--RCURLY -> } [26:9]
        |       |                                   `--LITERAL_ELSE -> else [26:11]
        |       |                                       `--LITERAL_IF -> if [26:16]
        |       |                                           |--LPAREN -> ( [26:19]
        |       |                                           |--EXPR -> EXPR [26:22]
        |       |                                           |   `--LITERAL_INSTANCEOF -> instanceof [26:22]
        |       |                                           |       |--IDENT -> r [26:20]
        |       |                                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:17]
        |       |                                           |           |--MODIFIERS -> MODIFIERS [27:17]
        |       |                                           |           |--TYPE -> TYPE [27:17]
        |       |                                           |           |   `--IDENT -> R [27:17]
        |       |                                           |           |--LPAREN -> ( [27:18]
        |       |                                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:19]
        |       |                                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:19]
        |       |                                           |           |       |--MODIFIERS -> MODIFIERS [27:19]
        |       |                                           |           |       |--TYPE -> TYPE [27:19]
        |       |                                           |           |       |   `--IDENT -> R [27:19]
        |       |                                           |           |       |--LPAREN -> ( [27:20]
        |       |                                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:21]
        |       |                                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:21]
        |       |                                           |           |       |       |--MODIFIERS -> MODIFIERS [27:21]
        |       |                                           |           |       |       |--TYPE -> TYPE [27:21]
        |       |                                           |           |       |       |   `--IDENT -> R [27:21]
        |       |                                           |           |       |       |--LPAREN -> ( [27:22]
        |       |                                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:23]
        |       |                                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:23]
        |       |                                           |           |       |       |       |--MODIFIERS -> MODIFIERS [27:23]
        |       |                                           |           |       |       |       |--TYPE -> TYPE [27:23]
        |       |                                           |           |       |       |       |   `--IDENT -> R [27:23]
        |       |                                           |           |       |       |       |--LPAREN -> ( [27:24]
        |       |                                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:25]
        |       |                                           |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:25]
        |       |                                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [27:25]
        |       |                                           |           |       |       |       |       |--TYPE -> TYPE [27:25]
        |       |                                           |           |       |       |       |       |   `--IDENT -> R [27:25]
        |       |                                           |           |       |       |       |       |--LPAREN -> ( [27:26]
        |       |                                           |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:27]
        |       |                                           |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:27]
        |       |                                           |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [27:27]
        |       |                                           |           |       |       |       |       |       |--TYPE -> TYPE [27:27]
        |       |                                           |           |       |       |       |       |       |   `--IDENT -> R [27:27]
        |       |                                           |           |       |       |       |       |       |--LPAREN -> ( [27:28]
        |       |                                           |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:29]
        |       |                                           |           |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:29]
        |       |                                           |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [27:29]
        |       |                                           |           |       |       |       |       |       |       |--TYPE -> TYPE [27:29]
        |       |                                           |           |       |       |       |       |       |       |   `--IDENT -> R [27:29]
        |       |                                           |           |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerRecordComponent [27:31]
        |       |                                           |           |       |       |       |       |       `--RPAREN -> ) [27:71]
        |       |                                           |           |       |       |       |       `--RPAREN -> ) [27:72]
        |       |                                           |           |       |       |       `--RPAREN -> ) [27:73]
        |       |                                           |           |       |       `--RPAREN -> ) [27:74]
        |       |                                           |           |       `--RPAREN -> ) [27:75]
        |       |                                           |           `--RPAREN -> ) [27:76]
        |       |                                           |--RPAREN -> ) [27:77]
        |       |                                           |--SLIST -> { [27:79]
        |       |                                           |   |--EXPR -> EXPR [28:31]
        |       |                                           |   |   `--METHOD_CALL -> ( [28:31]
        |       |                                           |   |       |--DOT -> . [28:23]
        |       |                                           |   |       |   |--DOT -> . [28:19]
        |       |                                           |   |       |   |   |--IDENT -> System [28:13]
        |       |                                           |   |       |   |   `--IDENT -> out [28:20]
        |       |                                           |   |       |   `--IDENT -> println [28:24]
        |       |                                           |   |       |--ELIST -> ELIST [28:32]
        |       |                                           |   |       |   `--EXPR -> EXPR [28:32]
        |       |                                           |   |       |       `--IDENT -> innerInnerInnerInnerInnerRecordComponent [28:32]
        |       |                                           |   |       `--RPAREN -> ) [28:72]
        |       |                                           |   |--SEMI -> ; [28:73]
        |       |                                           |   `--RCURLY -> } [29:9]
        |       |                                           `--LITERAL_ELSE -> else [29:11]
        |       |                                               `--LITERAL_IF -> if [29:16]
        |       |                                                   |--LPAREN -> ( [29:19]
        |       |                                                   |--EXPR -> EXPR [29:22]
        |       |                                                   |   `--LITERAL_INSTANCEOF -> instanceof [29:22]
        |       |                                                   |       |--IDENT -> r [29:20]
        |       |                                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:17]
        |       |                                                   |           |--MODIFIERS -> MODIFIERS [30:17]
        |       |                                                   |           |--TYPE -> TYPE [30:17]
        |       |                                                   |           |   `--IDENT -> R [30:17]
        |       |                                                   |           |--LPAREN -> ( [30:18]
        |       |                                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:19]
        |       |                                                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:19]
        |       |                                                   |           |       |--MODIFIERS -> MODIFIERS [30:19]
        |       |                                                   |           |       |--TYPE -> TYPE [30:19]
        |       |                                                   |           |       |   `--IDENT -> R [30:19]
        |       |                                                   |           |       |--LPAREN -> ( [30:20]
        |       |                                                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:21]
        |       |                                                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:21]
        |       |                                                   |           |       |       |--MODIFIERS -> MODIFIERS [30:21]
        |       |                                                   |           |       |       |--TYPE -> TYPE [30:21]
        |       |                                                   |           |       |       |   `--IDENT -> R [30:21]
        |       |                                                   |           |       |       |--LPAREN -> ( [30:22]
        |       |                                                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:23]
        |       |                                                   |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:23]
        |       |                                                   |           |       |       |       |--MODIFIERS -> MODIFIERS [30:23]
        |       |                                                   |           |       |       |       |--TYPE -> TYPE [30:23]
        |       |                                                   |           |       |       |       |   `--IDENT -> R [30:23]
        |       |                                                   |           |       |       |       |--LPAREN -> ( [30:24]
        |       |                                                   |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:25]
        |       |                                                   |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:25]
        |       |                                                   |           |       |       |       |       |--MODIFIERS -> MODIFIERS [30:25]
        |       |                                                   |           |       |       |       |       |--TYPE -> TYPE [30:25]
        |       |                                                   |           |       |       |       |       |   `--IDENT -> R [30:25]
        |       |                                                   |           |       |       |       |       |--LPAREN -> ( [30:26]
        |       |                                                   |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:27]
        |       |                                                   |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:27]
        |       |                                                   |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:27]
        |       |                                                   |           |       |       |       |       |       |--TYPE -> TYPE [30:27]
        |       |                                                   |           |       |       |       |       |       |   `--IDENT -> R [30:27]
        |       |                                                   |           |       |       |       |       |       |--LPAREN -> ( [30:28]
        |       |                                                   |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:29]
        |       |                                                   |           |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:29]
        |       |                                                   |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:29]
        |       |                                                   |           |       |       |       |       |       |       |--TYPE -> TYPE [30:29]
        |       |                                                   |           |       |       |       |       |       |       |   `--IDENT -> R [30:29]
        |       |                                                   |           |       |       |       |       |       |       |--LPAREN -> ( [30:30]
        |       |                                                   |           |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:31]
        |       |                                                   |           |       |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [30:31]
        |       |                                                   |           |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:31]
        |       |                                                   |           |       |       |       |       |       |       |       |--TYPE -> TYPE [30:31]
        |       |                                                   |           |       |       |       |       |       |       |       |   `--IDENT -> R [30:31]
        |       |                                                   |           |       |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerInnerRecordComponent [30:33]
        |       |                                                   |           |       |       |       |       |       |       `--RPAREN -> ) [30:78]
        |       |                                                   |           |       |       |       |       |       `--RPAREN -> ) [30:79]
        |       |                                                   |           |       |       |       |       `--RPAREN -> ) [30:80]
        |       |                                                   |           |       |       |       `--RPAREN -> ) [30:81]
        |       |                                                   |           |       |       `--RPAREN -> ) [30:82]
        |       |                                                   |           |       `--RPAREN -> ) [30:83]
        |       |                                                   |           `--RPAREN -> ) [30:84]
        |       |                                                   |--RPAREN -> ) [30:85]
        |       |                                                   |--SLIST -> { [30:87]
        |       |                                                   |   |--EXPR -> EXPR [31:31]
        |       |                                                   |   |   `--METHOD_CALL -> ( [31:31]
        |       |                                                   |   |       |--DOT -> . [31:23]
        |       |                                                   |   |       |   |--DOT -> . [31:19]
        |       |                                                   |   |       |   |   |--IDENT -> System [31:13]
        |       |                                                   |   |       |   |   `--IDENT -> out [31:20]
        |       |                                                   |   |       |   `--IDENT -> println [31:24]
        |       |                                                   |   |       |--ELIST -> ELIST [31:32]
        |       |                                                   |   |       |   `--EXPR -> EXPR [31:32]
        |       |                                                   |   |       |       `--IDENT -> innerInnerInnerInnerInnerInnerRecordComponent [31:32]
        |       |                                                   |   |       `--RPAREN -> ) [31:77]
        |       |                                                   |   |--SEMI -> ; [31:78]
        |       |                                                   |   `--RCURLY -> } [32:9]
        |       |                                                   `--LITERAL_ELSE -> else [32:11]
        |       |                                                       `--LITERAL_IF -> if [32:16]
        |       |                                                           |--LPAREN -> ( [32:19]
        |       |                                                           |--EXPR -> EXPR [32:22]
        |       |                                                           |   `--LITERAL_INSTANCEOF -> instanceof [32:22]
        |       |                                                           |       |--IDENT -> r [32:20]
        |       |                                                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:17]
        |       |                                                           |           |--MODIFIERS -> MODIFIERS [33:17]
        |       |                                                           |           |--TYPE -> TYPE [33:17]
        |       |                                                           |           |   `--IDENT -> R [33:17]
        |       |                                                           |           |--LPAREN -> ( [33:18]
        |       |                                                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:19]
        |       |                                                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:19]
        |       |                                                           |           |       |--MODIFIERS -> MODIFIERS [33:19]
        |       |                                                           |           |       |--TYPE -> TYPE [33:19]
        |       |                                                           |           |       |   `--IDENT -> R [33:19]
        |       |                                                           |           |       |--LPAREN -> ( [33:20]
        |       |                                                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:21]
        |       |                                                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:21]
        |       |                                                           |           |       |       |--MODIFIERS -> MODIFIERS [33:21]
        |       |                                                           |           |       |       |--TYPE -> TYPE [33:21]
        |       |                                                           |           |       |       |   `--IDENT -> R [33:21]
        |       |                                                           |           |       |       |--LPAREN -> ( [33:22]
        |       |                                                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:23]
        |       |                                                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:23]
        |       |                                                           |           |       |       |       |--MODIFIERS -> MODIFIERS [33:23]
        |       |                                                           |           |       |       |       |--TYPE -> TYPE [33:23]
        |       |                                                           |           |       |       |       |   `--IDENT -> R [33:23]
        |       |                                                           |           |       |       |       |--LPAREN -> ( [33:24]
        |       |                                                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:25]
        |       |                                                           |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:25]
        |       |                                                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [33:25]
        |       |                                                           |           |       |       |       |       |--TYPE -> TYPE [33:25]
        |       |                                                           |           |       |       |       |       |   `--IDENT -> R [33:25]
        |       |                                                           |           |       |       |       |       |--LPAREN -> ( [33:26]
        |       |                                                           |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:27]
        |       |                                                           |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:27]
        |       |                                                           |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:27]
        |       |                                                           |           |       |       |       |       |       |--TYPE -> TYPE [33:27]
        |       |                                                           |           |       |       |       |       |       |   `--IDENT -> R [33:27]
        |       |                                                           |           |       |       |       |       |       |--LPAREN -> ( [33:28]
        |       |                                                           |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:29]
        |       |                                                           |           |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:29]
        |       |                                                           |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:29]
        |       |                                                           |           |       |       |       |       |       |       |--TYPE -> TYPE [33:29]
        |       |                                                           |           |       |       |       |       |       |       |   `--IDENT -> R [33:29]
        |       |                                                           |           |       |       |       |       |       |       |--LPAREN -> ( [33:30]
        |       |                                                           |           |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:31]
        |       |                                                           |           |       |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:31]
        |       |                                                           |           |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:31]
        |       |                                                           |           |       |       |       |       |       |       |       |--TYPE -> TYPE [33:31]
        |       |                                                           |           |       |       |       |       |       |       |       |   `--IDENT -> R [33:31]
        |       |                                                           |           |       |       |       |       |       |       |       |--LPAREN -> ( [33:32]
        |       |                                                           |           |       |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:33]
        |       |                                                           |           |       |       |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [33:33]
        |       |                                                           |           |       |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:33]
        |       |                                                           |           |       |       |       |       |       |       |       |       |--TYPE -> TYPE [33:33]
        |       |                                                           |           |       |       |       |       |       |       |       |       |   `--IDENT -> R [33:33]
        |       |                                                           |           |       |       |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerInnerInnerRecordComponent [33:35]
        |       |                                                           |           |       |       |       |       |       |       |       `--RPAREN -> ) [33:85]
        |       |                                                           |           |       |       |       |       |       |       `--RPAREN -> ) [33:86]
        |       |                                                           |           |       |       |       |       |       `--RPAREN -> ) [33:87]
        |       |                                                           |           |       |       |       |       `--RPAREN -> ) [33:88]
        |       |                                                           |           |       |       |       `--RPAREN -> ) [33:89]
        |       |                                                           |           |       |       `--RPAREN -> ) [33:90]
        |       |                                                           |           |       `--RPAREN -> ) [33:91]
        |       |                                                           |           `--RPAREN -> ) [33:92]
        |       |                                                           |--RPAREN -> ) [33:93]
        |       |                                                           |--SLIST -> { [33:95]
        |       |                                                           |   |--EXPR -> EXPR [34:31]
        |       |                                                           |   |   `--METHOD_CALL -> ( [34:31]
        |       |                                                           |   |       |--DOT -> . [34:23]
        |       |                                                           |   |       |   |--DOT -> . [34:19]
        |       |                                                           |   |       |   |   |--IDENT -> System [34:13]
        |       |                                                           |   |       |   |   `--IDENT -> out [34:20]
        |       |                                                           |   |       |   `--IDENT -> println [34:24]
        |       |                                                           |   |       |--ELIST -> ELIST [34:32]
        |       |                                                           |   |       |   `--EXPR -> EXPR [34:32]
        |       |                                                           |   |       |       `--IDENT -> innerInnerInnerInnerInnerInnerInnerRecordComponent [34:32]
        |       |                                                           |   |       `--RPAREN -> ) [34:82]
        |       |                                                           |   |--SEMI -> ; [34:83]
        |       |                                                           |   `--RCURLY -> } [35:9]
        |       |                                                           `--LITERAL_ELSE -> else [35:11]
        |       |                                                               `--LITERAL_IF -> if [35:16]
        |       |                                                                   |--LPAREN -> ( [35:19]
        |       |                                                                   |--EXPR -> EXPR [35:22]
        |       |                                                                   |   `--LITERAL_INSTANCEOF -> instanceof [35:22]
        |       |                                                                   |       |--IDENT -> r [35:20]
        |       |                                                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [35:33]
        |       |                                                                   |           |--MODIFIERS -> MODIFIERS [35:33]
        |       |                                                                   |           |--TYPE -> TYPE [35:33]
        |       |                                                                   |           |   `--IDENT -> R [35:33]
        |       |                                                                   |           |--LPAREN -> ( [35:34]
        |       |                                                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [35:35]
        |       |                                                                   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [35:35]
        |       |                                                                   |           |       |--MODIFIERS -> MODIFIERS [35:35]
        |       |                                                                   |           |       |--TYPE -> TYPE [35:35]
        |       |                                                                   |           |       |   `--IDENT -> R [35:35]
        |       |                                                                   |           |       `--IDENT -> myRecord [35:37]
        |       |                                                                   |           `--RPAREN -> ) [35:45]
        |       |                                                                   |--RPAREN -> ) [35:46]
        |       |                                                                   `--SLIST -> { [35:48]
        |       |                                                                       |--LITERAL_IF -> if [36:13]
        |       |                                                                       |   |--LPAREN -> ( [36:16]
        |       |                                                                       |   |--EXPR -> EXPR [36:26]
        |       |                                                                       |   |   `--LITERAL_INSTANCEOF -> instanceof [36:26]
        |       |                                                                       |   |       |--IDENT -> myRecord [36:17]
        |       |                                                                       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:37]
        |       |                                                                       |   |           |--MODIFIERS -> MODIFIERS [36:37]
        |       |                                                                       |   |           |--TYPE -> TYPE [36:37]
        |       |                                                                       |   |           |   `--IDENT -> R [36:37]
        |       |                                                                       |   |           |--LPAREN -> ( [36:38]
        |       |                                                                       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:39]
        |       |                                                                       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [36:39]
        |       |                                                                       |   |           |       |--MODIFIERS -> MODIFIERS [36:39]
        |       |                                                                       |   |           |       |--TYPE -> TYPE [36:39]
        |       |                                                                       |   |           |       |   `--IDENT -> R [36:39]
        |       |                                                                       |   |           |       `--IDENT -> myInnerRecord [36:41]
        |       |                                                                       |   |           `--RPAREN -> ) [36:54]
        |       |                                                                       |   |--RPAREN -> ) [36:55]
        |       |                                                                       |   `--SLIST -> { [36:57]
        |       |                                                                       |       |--LITERAL_IF -> if [37:17]
        |       |                                                                       |       |   |--LPAREN -> ( [37:20]
        |       |                                                                       |       |   |--EXPR -> EXPR [37:35]
        |       |                                                                       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [37:35]
        |       |                                                                       |       |   |       |--IDENT -> myInnerRecord [37:21]
        |       |                                                                       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:46]
        |       |                                                                       |       |   |           |--MODIFIERS -> MODIFIERS [37:46]
        |       |                                                                       |       |   |           |--TYPE -> TYPE [37:46]
        |       |                                                                       |       |   |           |   `--IDENT -> R [37:46]
        |       |                                                                       |       |   |           |--LPAREN -> ( [37:47]
        |       |                                                                       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:48]
        |       |                                                                       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:48]
        |       |                                                                       |       |   |           |       |--MODIFIERS -> MODIFIERS [37:48]
        |       |                                                                       |       |   |           |       |--TYPE -> TYPE [37:48]
        |       |                                                                       |       |   |           |       |   `--IDENT -> R [37:48]
        |       |                                                                       |       |   |           |       `--IDENT -> myInnerInnerRecord [37:50]
        |       |                                                                       |       |   |           `--RPAREN -> ) [37:68]
        |       |                                                                       |       |   |--RPAREN -> ) [37:69]
        |       |                                                                       |       |   `--SLIST -> { [37:71]
        |       |                                                                       |       |       |--LITERAL_IF -> if [38:21]
        |       |                                                                       |       |       |   |--LPAREN -> ( [38:24]
        |       |                                                                       |       |       |   |--EXPR -> EXPR [38:44]
        |       |                                                                       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [38:44]
        |       |                                                                       |       |       |   |       |--IDENT -> myInnerInnerRecord [38:25]
        |       |                                                                       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:55]
        |       |                                                                       |       |       |   |           |--MODIFIERS -> MODIFIERS [38:55]
        |       |                                                                       |       |       |   |           |--TYPE -> TYPE [38:55]
        |       |                                                                       |       |       |   |           |   `--IDENT -> R [38:55]
        |       |                                                                       |       |       |   |           |--LPAREN -> ( [38:56]
        |       |                                                                       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:57]
        |       |                                                                       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:57]
        |       |                                                                       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [38:57]
        |       |                                                                       |       |       |   |           |       |--TYPE -> TYPE [38:57]
        |       |                                                                       |       |       |   |           |       |   `--IDENT -> R [38:57]
        |       |                                                                       |       |       |   |           |       `--IDENT -> myInnerInnerInnerRecord [38:59]
        |       |                                                                       |       |       |   |           `--RPAREN -> ) [38:82]
        |       |                                                                       |       |       |   |--RPAREN -> ) [38:83]
        |       |                                                                       |       |       |   `--SLIST -> { [38:85]
        |       |                                                                       |       |       |       |--LITERAL_IF -> if [39:25]
        |       |                                                                       |       |       |       |   |--LPAREN -> ( [39:28]
        |       |                                                                       |       |       |       |   |--EXPR -> EXPR [39:53]
        |       |                                                                       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [39:53]
        |       |                                                                       |       |       |       |   |       |--IDENT -> myInnerInnerInnerRecord [39:29]
        |       |                                                                       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [39:64]
        |       |                                                                       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [39:64]
        |       |                                                                       |       |       |       |   |           |--TYPE -> TYPE [39:64]
        |       |                                                                       |       |       |       |   |           |   `--IDENT -> R [39:64]
        |       |                                                                       |       |       |       |   |           |--LPAREN -> ( [39:65]
        |       |                                                                       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [39:66]
        |       |                                                                       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:66]
        |       |                                                                       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [39:66]
        |       |                                                                       |       |       |       |   |           |       |--TYPE -> TYPE [39:66]
        |       |                                                                       |       |       |       |   |           |       |   `--IDENT -> R [39:66]
        |       |                                                                       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerRecord [39:68]
        |       |                                                                       |       |       |       |   |           `--RPAREN -> ) [39:96]
        |       |                                                                       |       |       |       |   |--RPAREN -> ) [39:97]
        |       |                                                                       |       |       |       |   `--SLIST -> { [39:99]
        |       |                                                                       |       |       |       |       |--LITERAL_IF -> if [40:29]
        |       |                                                                       |       |       |       |       |   |--LPAREN -> ( [40:32]
        |       |                                                                       |       |       |       |       |   |--EXPR -> EXPR [40:62]
        |       |                                                                       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [40:62]
        |       |                                                                       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerRecord [40:33]
        |       |                                                                       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [41:37]
        |       |                                                                       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [41:37]
        |       |                                                                       |       |       |       |       |   |           |--TYPE -> TYPE [41:37]
        |       |                                                                       |       |       |       |       |   |           |   `--IDENT -> R [41:37]
        |       |                                                                       |       |       |       |       |   |           |--LPAREN -> ( [41:38]
        |       |                                                                       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [41:39]
        |       |                                                                       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:39]
        |       |                                                                       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [41:39]
        |       |                                                                       |       |       |       |       |   |           |       |--TYPE -> TYPE [41:39]
        |       |                                                                       |       |       |       |       |   |           |       |   `--IDENT -> R [41:39]
        |       |                                                                       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerRecord [41:41]
        |       |                                                                       |       |       |       |       |   |           `--RPAREN -> ) [41:74]
        |       |                                                                       |       |       |       |       |   |--RPAREN -> ) [41:75]
        |       |                                                                       |       |       |       |       |   `--SLIST -> { [41:77]
        |       |                                                                       |       |       |       |       |       |--LITERAL_IF -> if [42:33]
        |       |                                                                       |       |       |       |       |       |   |--LPAREN -> ( [42:36]
        |       |                                                                       |       |       |       |       |       |   |--EXPR -> EXPR [43:41]
        |       |                                                                       |       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [43:41]
        |       |                                                                       |       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerInnerRecord [42:37]
        |       |                                                                       |       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [43:52]
        |       |                                                                       |       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [43:52]
        |       |                                                                       |       |       |       |       |       |   |           |--TYPE -> TYPE [43:52]
        |       |                                                                       |       |       |       |       |       |   |           |   `--IDENT -> R [43:52]
        |       |                                                                       |       |       |       |       |       |   |           |--LPAREN -> ( [43:53]
        |       |                                                                       |       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [43:54]
        |       |                                                                       |       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:54]
        |       |                                                                       |       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [43:54]
        |       |                                                                       |       |       |       |       |       |   |           |       |--TYPE -> TYPE [43:54]
        |       |                                                                       |       |       |       |       |       |   |           |       |   `--IDENT -> R [43:54]
        |       |                                                                       |       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerInnerRecord [43:56]
        |       |                                                                       |       |       |       |       |       |   |           `--RPAREN -> ) [43:94]
        |       |                                                                       |       |       |       |       |       |   |--RPAREN -> ) [43:95]
        |       |                                                                       |       |       |       |       |       |   `--SLIST -> { [43:97]
        |       |                                                                       |       |       |       |       |       |       |--LITERAL_IF -> if [44:37]
        |       |                                                                       |       |       |       |       |       |       |   |--LPAREN -> ( [44:40]
        |       |                                                                       |       |       |       |       |       |       |   |--EXPR -> EXPR [45:45]
        |       |                                                                       |       |       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [45:45]
        |       |                                                                       |       |       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerInnerInnerRecord [44:41]
        |       |                                                                       |       |       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:56]
        |       |                                                                       |       |       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [45:56]
        |       |                                                                       |       |       |       |       |       |       |   |           |--TYPE -> TYPE [45:56]
        |       |                                                                       |       |       |       |       |       |       |   |           |   `--IDENT -> R [45:56]
        |       |                                                                       |       |       |       |       |       |       |   |           |--LPAREN -> ( [45:57]
        |       |                                                                       |       |       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [46:45]
        |       |                                                                       |       |       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:45]
        |       |                                                                       |       |       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [46:45]
        |       |                                                                       |       |       |       |       |       |       |   |           |       |--TYPE -> TYPE [46:45]
        |       |                                                                       |       |       |       |       |       |       |   |           |       |   `--IDENT -> R [46:45]
        |       |                                                                       |       |       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerInnerInnerRecord [47:53]
        |       |                                                                       |       |       |       |       |       |       |   |           `--RPAREN -> ) [48:37]
        |       |                                                                       |       |       |       |       |       |       |   |--RPAREN -> ) [48:38]
        |       |                                                                       |       |       |       |       |       |       |   `--SLIST -> { [48:40]
        |       |                                                                       |       |       |       |       |       |       |       `--RCURLY -> } [50:37]
        |       |                                                                       |       |       |       |       |       |       `--RCURLY -> } [51:33]
        |       |                                                                       |       |       |       |       |       `--RCURLY -> } [52:29]
        |       |                                                                       |       |       |       |       `--RCURLY -> } [53:25]
        |       |                                                                       |       |       |       `--RCURLY -> } [54:21]
        |       |                                                                       |       |       `--RCURLY -> } [55:17]
        |       |                                                                       |       `--RCURLY -> } [56:13]
        |       |                                                                       `--RCURLY -> } [57:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [60:9]
        |       |   |--MODIFIERS -> MODIFIERS [60:9]
        |       |   |   `--FINAL -> final [60:9]
        |       |   |--TYPE -> TYPE [60:15]
        |       |   |   |--IDENT -> List [60:15]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [60:19]
        |       |   |       |--GENERIC_START -> < [60:19]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [60:20]
        |       |   |       |   `--IDENT -> R [60:20]
        |       |   |       `--GENERIC_END -> > [60:21]
        |       |   |--IDENT -> list [60:23]
        |       |   `--ASSIGN -> = [60:28]
        |       |       `--EXPR -> EXPR [61:24]
        |       |           `--METHOD_CALL -> ( [61:24]
        |       |               |--DOT -> . [61:21]
        |       |               |   |--IDENT -> List [61:17]
        |       |               |   `--IDENT -> of [61:22]
        |       |               |--ELIST -> ELIST [61:25]
        |       |               |   `--EXPR -> EXPR [61:25]
        |       |               |       `--LITERAL_NEW -> new [61:25]
        |       |               |           |--IDENT -> R [61:29]
        |       |               |           |--LPAREN -> ( [61:30]
        |       |               |           |--ELIST -> ELIST [61:31]
        |       |               |           |   `--EXPR -> EXPR [61:31]
        |       |               |           |       `--LITERAL_NEW -> new [61:31]
        |       |               |           |           |--IDENT -> R [61:35]
        |       |               |           |           |--LPAREN -> ( [61:36]
        |       |               |           |           |--ELIST -> ELIST [61:37]
        |       |               |           |           |   `--EXPR -> EXPR [61:37]
        |       |               |           |           |       `--LITERAL_NEW -> new [61:37]
        |       |               |           |           |           |--IDENT -> R [61:41]
        |       |               |           |           |           |--LPAREN -> ( [61:42]
        |       |               |           |           |           |--ELIST -> ELIST [61:43]
        |       |               |           |           |           |   `--EXPR -> EXPR [61:43]
        |       |               |           |           |           |       `--LITERAL_NEW -> new [61:43]
        |       |               |           |           |           |           |--IDENT -> R [61:47]
        |       |               |           |           |           |           |--LPAREN -> ( [61:48]
        |       |               |           |           |           |           |--ELIST -> ELIST [61:49]
        |       |               |           |           |           |           |   `--EXPR -> EXPR [61:49]
        |       |               |           |           |           |           |       `--LITERAL_NEW -> new [61:49]
        |       |               |           |           |           |           |           |--IDENT -> R [62:25]
        |       |               |           |           |           |           |           |--LPAREN -> ( [62:26]
        |       |               |           |           |           |           |           |--ELIST -> ELIST [62:27]
        |       |               |           |           |           |           |           |   `--EXPR -> EXPR [62:27]
        |       |               |           |           |           |           |           |       `--LITERAL_NEW -> new [62:27]
        |       |               |           |           |           |           |           |           |--IDENT -> R [62:31]
        |       |               |           |           |           |           |           |           |--LPAREN -> ( [62:32]
        |       |               |           |           |           |           |           |           |--ELIST -> ELIST [62:33]
        |       |               |           |           |           |           |           |           |   `--EXPR -> EXPR [62:33]
        |       |               |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:33]
        |       |               |           |           |           |           |           |           |           |--IDENT -> R [62:37]
        |       |               |           |           |           |           |           |           |           |--LPAREN -> ( [62:38]
        |       |               |           |           |           |           |           |           |           |--ELIST -> ELIST [62:39]
        |       |               |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:39]
        |       |               |           |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:39]
        |       |               |           |           |           |           |           |           |           |           |--IDENT -> R [62:43]
        |       |               |           |           |           |           |           |           |           |           |--LPAREN -> ( [62:44]
        |       |               |           |           |           |           |           |           |           |           |--ELIST -> ELIST [62:45]
        |       |               |           |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:45]
        |       |               |           |           |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:45]
        |       |               |           |           |           |           |           |           |           |           |           |--IDENT -> R [62:49]
        |       |               |           |           |           |           |           |           |           |           |           |--LPAREN -> ( [62:50]
        |       |               |           |           |           |           |           |           |           |           |           |--ELIST -> ELIST [62:51]
        |       |               |           |           |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:51]
        |       |               |           |           |           |           |           |           |           |           |           |       `--LITERAL_NULL -> null [62:51]
        |       |               |           |           |           |           |           |           |           |           |           `--RPAREN -> ) [62:55]
        |       |               |           |           |           |           |           |           |           |           `--RPAREN -> ) [62:56]
        |       |               |           |           |           |           |           |           |           `--RPAREN -> ) [62:57]
        |       |               |           |           |           |           |           |           `--RPAREN -> ) [62:58]
        |       |               |           |           |           |           |           `--RPAREN -> ) [62:59]
        |       |               |           |           |           |           `--RPAREN -> ) [62:60]
        |       |               |           |           |           `--RPAREN -> ) [62:61]
        |       |               |           |           `--RPAREN -> ) [62:62]
        |       |               |           `--RPAREN -> ) [62:63]
        |       |               `--RPAREN -> ) [62:64]
        |       |--SEMI -> ; [62:65]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [64:9]
        |       |   |--MODIFIERS -> MODIFIERS [64:9]
        |       |   |   `--FINAL -> final [64:9]
        |       |   |--TYPE -> TYPE [64:15]
        |       |   |   `--IDENT -> Object [64:15]
        |       |   |--IDENT -> o [64:22]
        |       |   `--ASSIGN -> = [64:24]
        |       |       `--EXPR -> EXPR [64:34]
        |       |           `--METHOD_CALL -> ( [64:34]
        |       |               |--DOT -> . [64:30]
        |       |               |   |--IDENT -> list [64:26]
        |       |               |   `--IDENT -> get [64:31]
        |       |               |--ELIST -> ELIST [64:35]
        |       |               |   `--EXPR -> EXPR [64:35]
        |       |               |       `--NUM_INT -> 0 [64:35]
        |       |               `--RPAREN -> ) [64:36]
        |       |--SEMI -> ; [64:37]
        |       |--LITERAL_FOR -> for [65:9]
        |       |   |--LPAREN -> ( [65:13]
        |       |   |--FOR_INIT -> FOR_INIT [65:14]
        |       |   |--SEMI -> ; [65:14]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [65:18]
        |       |   |   `--EXPR -> EXPR [65:18]
        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [65:18]
        |       |   |           |--IDENT -> o [65:16]
        |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [65:29]
        |       |   |               |--MODIFIERS -> MODIFIERS [65:29]
        |       |   |               |--TYPE -> TYPE [65:29]
        |       |   |               |   `--IDENT -> R [65:29]
        |       |   |               |--LPAREN -> ( [65:30]
        |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [65:31]
        |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [65:31]
        |       |   |               |       |--MODIFIERS -> MODIFIERS [65:31]
        |       |   |               |       |--TYPE -> TYPE [65:31]
        |       |   |               |       |   `--IDENT -> R [65:31]
        |       |   |               |       `--IDENT -> rListElement [65:33]
        |       |   |               `--RPAREN -> ) [65:45]
        |       |   |--SEMI -> ; [65:46]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [65:48]
        |       |   |--RPAREN -> ) [65:48]
        |       |   `--SLIST -> { [65:50]
        |       |       |--LITERAL_FOR -> for [66:13]
        |       |       |   |--LPAREN -> ( [66:17]
        |       |       |   |--FOR_INIT -> FOR_INIT [66:18]
        |       |       |   |--SEMI -> ; [66:18]
        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [66:33]
        |       |       |   |   `--EXPR -> EXPR [66:33]
        |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [66:33]
        |       |       |   |           |--IDENT -> rListElement [66:20]
        |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [66:44]
        |       |       |   |               |--MODIFIERS -> MODIFIERS [66:44]
        |       |       |   |               |--TYPE -> TYPE [66:44]
        |       |       |   |               |   `--IDENT -> R [66:44]
        |       |       |   |               |--LPAREN -> ( [66:45]
        |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [66:46]
        |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [66:46]
        |       |       |   |               |       |--MODIFIERS -> MODIFIERS [66:46]
        |       |       |   |               |       |--TYPE -> TYPE [66:46]
        |       |       |   |               |       |   `--IDENT -> R [66:46]
        |       |       |   |               |       `--IDENT -> rListElementInner [66:48]
        |       |       |   |               |--RPAREN -> ) [66:65]
        |       |       |   |               `--IDENT -> r5 [66:67]
        |       |       |   |--SEMI -> ; [66:69]
        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [66:71]
        |       |       |   |--RPAREN -> ) [66:71]
        |       |       |   `--SLIST -> { [66:73]
        |       |       |       |--LITERAL_FOR -> for [67:17]
        |       |       |       |   |--LPAREN -> ( [67:21]
        |       |       |       |   |--FOR_INIT -> FOR_INIT [67:22]
        |       |       |       |   |--SEMI -> ; [67:22]
        |       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [67:42]
        |       |       |       |   |   `--EXPR -> EXPR [67:42]
        |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [67:42]
        |       |       |       |   |           |--IDENT -> rListElementInner [67:24]
        |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [67:53]
        |       |       |       |   |               |--MODIFIERS -> MODIFIERS [67:53]
        |       |       |       |   |               |--TYPE -> TYPE [67:53]
        |       |       |       |   |               |   `--IDENT -> R [67:53]
        |       |       |       |   |               |--LPAREN -> ( [67:54]
        |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [67:55]
        |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:55]
        |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [67:55]
        |       |       |       |   |               |       |--TYPE -> TYPE [67:55]
        |       |       |       |   |               |       |   `--IDENT -> R [67:55]
        |       |       |       |   |               |       `--IDENT -> rListElementInnerInner [67:57]
        |       |       |       |   |               `--RPAREN -> ) [67:79]
        |       |       |       |   |--SEMI -> ; [67:80]
        |       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [67:82]
        |       |       |       |   |--RPAREN -> ) [67:82]
        |       |       |       |   `--SLIST -> { [67:84]
        |       |       |       |       |--LITERAL_FOR -> for [68:21]
        |       |       |       |       |   |--LPAREN -> ( [68:25]
        |       |       |       |       |   |--FOR_INIT -> FOR_INIT [68:26]
        |       |       |       |       |   |--SEMI -> ; [68:26]
        |       |       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [68:51]
        |       |       |       |       |   |   `--EXPR -> EXPR [68:51]
        |       |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [68:51]
        |       |       |       |       |   |           |--IDENT -> rListElementInnerInner [68:28]
        |       |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [68:62]
        |       |       |       |       |   |               |--MODIFIERS -> MODIFIERS [68:62]
        |       |       |       |       |   |               |--TYPE -> TYPE [68:62]
        |       |       |       |       |   |               |   `--IDENT -> R [68:62]
        |       |       |       |       |   |               |--LPAREN -> ( [68:63]
        |       |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [68:64]
        |       |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:64]
        |       |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [68:64]
        |       |       |       |       |   |               |       |--TYPE -> TYPE [68:64]
        |       |       |       |       |   |               |       |   `--IDENT -> R [68:64]
        |       |       |       |       |   |               |       `--IDENT -> rListElementInnerInnerInner [68:66]
        |       |       |       |       |   |               `--RPAREN -> ) [68:93]
        |       |       |       |       |   |--SEMI -> ; [68:94]
        |       |       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [68:96]
        |       |       |       |       |   |--RPAREN -> ) [68:96]
        |       |       |       |       |   `--SLIST -> { [68:98]
        |       |       |       |       |       `--RCURLY -> } [69:21]
        |       |       |       |       `--RCURLY -> } [70:17]
        |       |       |       `--RCURLY -> } [71:13]
        |       |       `--RCURLY -> } [72:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [74:9]
        |       |   |--MODIFIERS -> MODIFIERS [74:9]
        |       |   |   `--FINAL -> final [74:9]
        |       |   |--TYPE -> TYPE [74:15]
        |       |   |   `--IDENT -> Iterator [74:15]
        |       |   |--IDENT -> it [74:24]
        |       |   `--ASSIGN -> = [74:27]
        |       |       `--EXPR -> EXPR [74:42]
        |       |           `--METHOD_CALL -> ( [74:42]
        |       |               |--DOT -> . [74:33]
        |       |               |   |--IDENT -> list [74:29]
        |       |               |   `--IDENT -> iterator [74:34]
        |       |               |--ELIST -> ELIST [74:43]
        |       |               `--RPAREN -> ) [74:43]
        |       |--SEMI -> ; [74:44]
        |       |--LITERAL_WHILE -> while [75:9]
        |       |   |--LPAREN -> ( [75:15]
        |       |   |--EXPR -> EXPR [75:29]
        |       |   |   `--LAND -> && [75:29]
        |       |   |       |--METHOD_CALL -> ( [75:26]
        |       |   |       |   |--DOT -> . [75:18]
        |       |   |       |   |   |--IDENT -> it [75:16]
        |       |   |       |   |   `--IDENT -> hasNext [75:19]
        |       |   |       |   |--ELIST -> ELIST [75:27]
        |       |   |       |   `--RPAREN -> ) [75:27]
        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [75:42]
        |       |   |           |--METHOD_CALL -> ( [75:39]
        |       |   |           |   |--DOT -> . [75:34]
        |       |   |           |   |   |--IDENT -> it [75:32]
        |       |   |           |   |   `--IDENT -> next [75:35]
        |       |   |           |   |--ELIST -> ELIST [75:40]
        |       |   |           |   `--RPAREN -> ) [75:40]
        |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [75:53]
        |       |   |               |--MODIFIERS -> MODIFIERS [75:53]
        |       |   |               |--TYPE -> TYPE [75:53]
        |       |   |               |   `--IDENT -> R [75:53]
        |       |   |               |--LPAREN -> ( [75:54]
        |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [75:55]
        |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:55]
        |       |   |               |       |--MODIFIERS -> MODIFIERS [75:55]
        |       |   |               |       |--TYPE -> TYPE [75:55]
        |       |   |               |       |   `--IDENT -> R [75:55]
        |       |   |               |       `--IDENT -> rListElement2 [75:57]
        |       |   |               |--RPAREN -> ) [75:70]
        |       |   |               `--IDENT -> r6 [75:72]
        |       |   |--RPAREN -> ) [75:74]
        |       |   `--SLIST -> { [75:76]
        |       |       |--LITERAL_WHILE -> while [76:13]
        |       |       |   |--LPAREN -> ( [76:19]
        |       |       |   |--EXPR -> EXPR [76:33]
        |       |       |   |   `--LAND -> && [76:33]
        |       |       |   |       |--METHOD_CALL -> ( [76:30]
        |       |       |   |       |   |--DOT -> . [76:22]
        |       |       |   |       |   |   |--IDENT -> it [76:20]
        |       |       |   |       |   |   `--IDENT -> hasNext [76:23]
        |       |       |   |       |   |--ELIST -> ELIST [76:31]
        |       |       |   |       |   `--RPAREN -> ) [76:31]
        |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [76:46]
        |       |       |   |           |--METHOD_CALL -> ( [76:43]
        |       |       |   |           |   |--DOT -> . [76:38]
        |       |       |   |           |   |   |--IDENT -> it [76:36]
        |       |       |   |           |   |   `--IDENT -> next [76:39]
        |       |       |   |           |   |--ELIST -> ELIST [76:44]
        |       |       |   |           |   `--RPAREN -> ) [76:44]
        |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [76:57]
        |       |       |   |               |--MODIFIERS -> MODIFIERS [76:57]
        |       |       |   |               |--TYPE -> TYPE [76:57]
        |       |       |   |               |   `--IDENT -> R [76:57]
        |       |       |   |               |--LPAREN -> ( [76:58]
        |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [76:59]
        |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:59]
        |       |       |   |               |       |--MODIFIERS -> MODIFIERS [76:59]
        |       |       |   |               |       |--TYPE -> TYPE [76:59]
        |       |       |   |               |       |   `--IDENT -> R [76:59]
        |       |       |   |               |       `--IDENT -> rListElementInner2 [76:61]
        |       |       |   |               `--RPAREN -> ) [76:79]
        |       |       |   |--RPAREN -> ) [76:80]
        |       |       |   `--SLIST -> { [76:82]
        |       |       |       |--LITERAL_WHILE -> while [77:17]
        |       |       |       |   |--LPAREN -> ( [77:23]
        |       |       |       |   |--EXPR -> EXPR [77:37]
        |       |       |       |   |   `--LAND -> && [77:37]
        |       |       |       |   |       |--METHOD_CALL -> ( [77:34]
        |       |       |       |   |       |   |--DOT -> . [77:26]
        |       |       |       |   |       |   |   |--IDENT -> it [77:24]
        |       |       |       |   |       |   |   `--IDENT -> hasNext [77:27]
        |       |       |       |   |       |   |--ELIST -> ELIST [77:35]
        |       |       |       |   |       |   `--RPAREN -> ) [77:35]
        |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [77:50]
        |       |       |       |   |           |--METHOD_CALL -> ( [77:47]
        |       |       |       |   |           |   |--DOT -> . [77:42]
        |       |       |       |   |           |   |   |--IDENT -> it [77:40]
        |       |       |       |   |           |   |   `--IDENT -> next [77:43]
        |       |       |       |   |           |   |--ELIST -> ELIST [77:48]
        |       |       |       |   |           |   `--RPAREN -> ) [77:48]
        |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [77:61]
        |       |       |       |   |               |--MODIFIERS -> MODIFIERS [77:61]
        |       |       |       |   |               |--TYPE -> TYPE [77:61]
        |       |       |       |   |               |   `--IDENT -> R [77:61]
        |       |       |       |   |               |--LPAREN -> ( [77:62]
        |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [77:63]
        |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [77:63]
        |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [77:63]
        |       |       |       |   |               |       |--TYPE -> TYPE [77:63]
        |       |       |       |   |               |       |   `--IDENT -> R [77:63]
        |       |       |       |   |               |       `--IDENT -> rListElementInnerInner2 [77:65]
        |       |       |       |   |               `--RPAREN -> ) [77:88]
        |       |       |       |   |--RPAREN -> ) [77:89]
        |       |       |       |   `--SLIST -> { [77:91]
        |       |       |       |       |--LITERAL_WHILE -> while [78:21]
        |       |       |       |       |   |--LPAREN -> ( [78:27]
        |       |       |       |       |   |--EXPR -> EXPR [78:41]
        |       |       |       |       |   |   `--LAND -> && [78:41]
        |       |       |       |       |   |       |--METHOD_CALL -> ( [78:38]
        |       |       |       |       |   |       |   |--DOT -> . [78:30]
        |       |       |       |       |   |       |   |   |--IDENT -> it [78:28]
        |       |       |       |       |   |       |   |   `--IDENT -> hasNext [78:31]
        |       |       |       |       |   |       |   |--ELIST -> ELIST [78:39]
        |       |       |       |       |   |       |   `--RPAREN -> ) [78:39]
        |       |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [78:54]
        |       |       |       |       |   |           |--METHOD_CALL -> ( [78:51]
        |       |       |       |       |   |           |   |--DOT -> . [78:46]
        |       |       |       |       |   |           |   |   |--IDENT -> it [78:44]
        |       |       |       |       |   |           |   |   `--IDENT -> next [78:47]
        |       |       |       |       |   |           |   |--ELIST -> ELIST [78:52]
        |       |       |       |       |   |           |   `--RPAREN -> ) [78:52]
        |       |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [78:65]
        |       |       |       |       |   |               |--MODIFIERS -> MODIFIERS [78:65]
        |       |       |       |       |   |               |--TYPE -> TYPE [78:65]
        |       |       |       |       |   |               |   `--IDENT -> R [78:65]
        |       |       |       |       |   |               |--LPAREN -> ( [78:66]
        |       |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [78:67]
        |       |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [78:67]
        |       |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [78:67]
        |       |       |       |       |   |               |       |--TYPE -> TYPE [78:67]
        |       |       |       |       |   |               |       |   `--IDENT -> R [78:67]
        |       |       |       |       |   |               |       `--IDENT -> rListElementInnerInnerInner2 [78:69]
        |       |       |       |       |   |               `--RPAREN -> ) [78:97]
        |       |       |       |       |   |--RPAREN -> ) [78:98]
        |       |       |       |       |   `--SLIST -> { [78:100]
        |       |       |       |       |       `--RCURLY -> } [79:21]
        |       |       |       |       `--RCURLY -> } [80:17]
        |       |       |       `--RCURLY -> } [81:13]
        |       |       `--RCURLY -> } [82:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [84:9]
        |       |   |--MODIFIERS -> MODIFIERS [84:9]
        |       |   |   `--FINAL -> final [84:9]
        |       |   |--TYPE -> TYPE [84:15]
        |       |   |   `--IDENT -> Object [84:15]
        |       |   |--IDENT -> myObj [84:22]
        |       |   `--ASSIGN -> = [84:28]
        |       |       `--EXPR -> EXPR [87:17]
        |       |           `--QUESTION -> ? [87:17]
        |       |               |--LAND -> && [86:17]
        |       |               |   |--LAND -> && [85:17]
        |       |               |   |   |--LITERAL_INSTANCEOF -> instanceof [84:42]
        |       |               |   |   |   |--METHOD_CALL -> ( [84:38]
        |       |               |   |   |   |   |--DOT -> . [84:34]
        |       |               |   |   |   |   |   |--IDENT -> list [84:30]
        |       |               |   |   |   |   |   `--IDENT -> get [84:35]
        |       |               |   |   |   |   |--ELIST -> ELIST [84:39]
        |       |               |   |   |   |   |   `--EXPR -> EXPR [84:39]
        |       |               |   |   |   |   |       `--NUM_INT -> 0 [84:39]
        |       |               |   |   |   |   `--RPAREN -> ) [84:40]
        |       |               |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [84:53]
        |       |               |   |   |       |--MODIFIERS -> MODIFIERS [84:53]
        |       |               |   |   |       |--TYPE -> TYPE [84:53]
        |       |               |   |   |       |   `--IDENT -> R [84:53]
        |       |               |   |   |       |--LPAREN -> ( [84:54]
        |       |               |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [84:55]
        |       |               |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:55]
        |       |               |   |   |       |       |--MODIFIERS -> MODIFIERS [84:55]
        |       |               |   |   |       |       |--TYPE -> TYPE [84:55]
        |       |               |   |   |       |       |   `--IDENT -> R [84:55]
        |       |               |   |   |       |       `--IDENT -> myRecord2 [84:57]
        |       |               |   |   |       |--RPAREN -> ) [84:66]
        |       |               |   |   |       `--IDENT -> r7 [84:68]
        |       |               |   |   `--LITERAL_INSTANCEOF -> instanceof [85:30]
        |       |               |   |       |--IDENT -> myRecord2 [85:20]
        |       |               |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [85:41]
        |       |               |   |           |--MODIFIERS -> MODIFIERS [85:41]
        |       |               |   |           |--TYPE -> TYPE [85:41]
        |       |               |   |           |   `--IDENT -> R [85:41]
        |       |               |   |           |--LPAREN -> ( [85:42]
        |       |               |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [85:43]
        |       |               |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:43]
        |       |               |   |           |       |--MODIFIERS -> MODIFIERS [85:43]
        |       |               |   |           |       |--TYPE -> TYPE [85:43]
        |       |               |   |           |       |   `--IDENT -> R [85:43]
        |       |               |   |           |       `--IDENT -> someComponent [85:45]
        |       |               |   |           `--RPAREN -> ) [85:58]
        |       |               |   `--LITERAL_INSTANCEOF -> instanceof [86:34]
        |       |               |       |--IDENT -> someComponent [86:20]
        |       |               |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [86:45]
        |       |               |           |--MODIFIERS -> MODIFIERS [86:45]
        |       |               |           |--TYPE -> TYPE [86:45]
        |       |               |           |   `--IDENT -> R [86:45]
        |       |               |           |--LPAREN -> ( [86:46]
        |       |               |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [86:47]
        |       |               |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [86:47]
        |       |               |           |       |--MODIFIERS -> MODIFIERS [86:47]
        |       |               |           |       |--TYPE -> TYPE [86:47]
        |       |               |           |       |   `--IDENT -> R [86:47]
        |       |               |           |       |--LPAREN -> ( [86:48]
        |       |               |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [86:49]
        |       |               |           |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [86:49]
        |       |               |           |       |       |--MODIFIERS -> MODIFIERS [86:49]
        |       |               |           |       |       |--TYPE -> TYPE [86:49]
        |       |               |           |       |       |   `--IDENT -> R [86:49]
        |       |               |           |       |       `--IDENT -> someComponent2 [86:51]
        |       |               |           |       `--RPAREN -> ) [86:65]
        |       |               |           `--RPAREN -> ) [86:66]
        |       |               |--IDENT -> myRecord2 [87:19]
        |       |               |--COLON -> : [87:29]
        |       |               `--LITERAL_NULL -> null [87:31]
        |       |--SEMI -> ; [87:35]
        |       `--RCURLY -> } [88:5]
        `--RCURLY -> } [89:1]
