COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java20 [2:49]
|   `--SEMI -> ; [2:55]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> ArrayList [4:18]
|   `--SEMI -> ; [4:27]
|--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 -> InputJava20RecordDecompositionEnhancedForLoop [7:14]
    `--OBJBLOCK -> OBJBLOCK [7:60]
        |--LCURLY -> { [7:60]
        |--RECORD_DEF -> RECORD_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |   `--LITERAL_PUBLIC -> public [8:5]
        |   |--LITERAL_RECORD -> record [8:12]
        |   |--IDENT -> InnerRecord [8:19]
        |   |--LPAREN -> ( [8:30]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:31]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:31]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [8:31]
        |   |   |   |--TYPE -> TYPE [8:31]
        |   |   |   |   `--IDENT -> String [8:31]
        |   |   |   `--IDENT -> a [8:38]
        |   |   |--COMMA -> , [8:39]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:41]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:41]
        |   |       |--TYPE -> TYPE [8:41]
        |   |       |   `--IDENT -> String [8:41]
        |   |       `--IDENT -> b [8:48]
        |   |--RPAREN -> ) [8:49]
        |   `--OBJBLOCK -> OBJBLOCK [8:51]
        |       |--LCURLY -> { [8:51]
        |       `--RCURLY -> } [9:5]
        |--RECORD_DEF -> RECORD_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |   `--LITERAL_PUBLIC -> public [11:5]
        |   |--LITERAL_RECORD -> record [11:12]
        |   |--IDENT -> OtherInnerRecord [11:19]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [11:35]
        |   |   |--GENERIC_START -> < [11:35]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:36]
        |   |   |   `--IDENT -> T [11:36]
        |   |   `--GENERIC_END -> > [11:37]
        |   |--LPAREN -> ( [11:38]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [11:39]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [11:39]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [11:39]
        |   |   |   |--TYPE -> TYPE [11:39]
        |   |   |   |   `--IDENT -> T [11:39]
        |   |   |   `--IDENT -> a [11:41]
        |   |   |--COMMA -> , [11:42]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [11:44]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [11:44]
        |   |       |--TYPE -> TYPE [11:44]
        |   |       |   `--IDENT -> T [11:44]
        |   |       `--IDENT -> b [11:46]
        |   |--RPAREN -> ) [11:47]
        |   `--OBJBLOCK -> OBJBLOCK [11:49]
        |       |--LCURLY -> { [11:49]
        |       `--RCURLY -> } [12:5]
        |--CTOR_DEF -> CTOR_DEF [14:5]
        |   |--MODIFIERS -> MODIFIERS [14:5]
        |   |   `--LITERAL_PUBLIC -> public [14:5]
        |   |--IDENT -> InputJava20RecordDecompositionEnhancedForLoop [14:12]
        |   |--LPAREN -> ( [14:57]
        |   |--PARAMETERS -> PARAMETERS [14:58]
        |   |--RPAREN -> ) [14:58]
        |   `--SLIST -> { [14:60]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [15:9]
        |       |   |--MODIFIERS -> MODIFIERS [15:9]
        |       |   |--TYPE -> TYPE [15:9]
        |       |   |   |--IDENT -> List [15:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:13]
        |       |   |       |--GENERIC_START -> < [15:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:14]
        |       |   |       |   `--IDENT -> InnerRecord [15:14]
        |       |   |       `--GENERIC_END -> > [15:25]
        |       |   |--IDENT -> aList [15:27]
        |       |   `--ASSIGN -> = [15:33]
        |       |       `--EXPR -> EXPR [15:35]
        |       |           `--LITERAL_NEW -> new [15:35]
        |       |               |--IDENT -> ArrayList [15:39]
        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:48]
        |       |               |   |--GENERIC_START -> < [15:48]
        |       |               |   `--GENERIC_END -> > [15:49]
        |       |               |--LPAREN -> ( [15:50]
        |       |               |--ELIST -> ELIST [15:51]
        |       |               |   `--EXPR -> EXPR [15:51]
        |       |               |       `--NUM_INT -> 1 [15:51]
        |       |               `--RPAREN -> ) [15:52]
        |       |--SEMI -> ; [15:53]
        |       |--EXPR -> EXPR [16:18]
        |       |   `--METHOD_CALL -> ( [16:18]
        |       |       |--DOT -> . [16:14]
        |       |       |   |--IDENT -> aList [16:9]
        |       |       |   `--IDENT -> add [16:15]
        |       |       |--ELIST -> ELIST [16:19]
        |       |       |   `--EXPR -> EXPR [16:19]
        |       |       |       `--LITERAL_NEW -> new [16:19]
        |       |       |           |--IDENT -> InnerRecord [16:23]
        |       |       |           |--LPAREN -> ( [16:34]
        |       |       |           |--ELIST -> ELIST [16:35]
        |       |       |           |   |--EXPR -> EXPR [16:35]
        |       |       |           |   |   `--STRING_LITERAL -> "a" [16:35]
        |       |       |           |   |--COMMA -> , [16:38]
        |       |       |           |   `--EXPR -> EXPR [16:40]
        |       |       |           |       `--STRING_LITERAL -> "b" [16:40]
        |       |       |           `--RPAREN -> ) [16:43]
        |       |       `--RPAREN -> ) [16:44]
        |       |--SEMI -> ; [16:45]
        |       |--LITERAL_FOR -> for [17:9]
        |       |   |--LPAREN -> ( [17:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [17:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [17:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [17:14]
        |       |   |   |   |--TYPE -> TYPE [17:14]
        |       |   |   |   |   `--IDENT -> InnerRecord [17:14]
        |       |   |   |   |--LPAREN -> ( [17:25]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [17:26]
        |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [17:26]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [17:26]
        |       |   |   |   |   |   |--TYPE -> TYPE [17:26]
        |       |   |   |   |   |   |   `--IDENT -> String [17:26]
        |       |   |   |   |   |   `--IDENT -> a [17:33]
        |       |   |   |   |   |--COMMA -> , [17:34]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [17:36]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [17:36]
        |       |   |   |   |       |--TYPE -> TYPE [17:36]
        |       |   |   |   |       |   `--IDENT -> String [17:36]
        |       |   |   |   |       `--IDENT -> b [17:43]
        |       |   |   |   `--RPAREN -> ) [17:44]
        |       |   |   |--COLON -> : [17:46]
        |       |   |   `--EXPR -> EXPR [17:48]
        |       |   |       `--IDENT -> aList [17:48]
        |       |   |--RPAREN -> ) [17:53]
        |       |   `--SLIST -> { [17:55]
        |       |       `--RCURLY -> } [17:56]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [19:9]
        |       |   |--MODIFIERS -> MODIFIERS [19:9]
        |       |   |--TYPE -> TYPE [19:9]
        |       |   |   |--IDENT -> List [19:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:13]
        |       |   |       |--GENERIC_START -> < [19:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:14]
        |       |   |       |   |--IDENT -> OtherInnerRecord [19:14]
        |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:30]
        |       |   |       |       |--GENERIC_START -> < [19:30]
        |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:31]
        |       |   |       |       |   `--IDENT -> InnerRecord [19:31]
        |       |   |       |       `--GENERIC_END -> > [19:42]
        |       |   |       `--GENERIC_END -> > [19:43]
        |       |   |--IDENT -> bList [19:45]
        |       |   `--ASSIGN -> = [19:51]
        |       |       `--EXPR -> EXPR [20:17]
        |       |           `--LITERAL_NEW -> new [20:17]
        |       |               |--IDENT -> ArrayList [20:21]
        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [20:30]
        |       |               |   |--GENERIC_START -> < [20:30]
        |       |               |   `--GENERIC_END -> > [20:31]
        |       |               |--LPAREN -> ( [20:32]
        |       |               |--ELIST -> ELIST [20:33]
        |       |               |   `--EXPR -> EXPR [20:33]
        |       |               |       `--NUM_INT -> 1 [20:33]
        |       |               `--RPAREN -> ) [20:34]
        |       |--SEMI -> ; [20:35]
        |       |--EXPR -> EXPR [21:18]
        |       |   `--METHOD_CALL -> ( [21:18]
        |       |       |--DOT -> . [21:14]
        |       |       |   |--IDENT -> bList [21:9]
        |       |       |   `--IDENT -> add [21:15]
        |       |       |--ELIST -> ELIST [21:19]
        |       |       |   `--EXPR -> EXPR [21:19]
        |       |       |       `--LITERAL_NEW -> new [21:19]
        |       |       |           |--IDENT -> OtherInnerRecord [21:23]
        |       |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [21:39]
        |       |       |           |   |--GENERIC_START -> < [21:39]
        |       |       |           |   `--GENERIC_END -> > [21:40]
        |       |       |           |--LPAREN -> ( [21:41]
        |       |       |           |--ELIST -> ELIST [22:17]
        |       |       |           |   |--EXPR -> EXPR [22:17]
        |       |       |           |   |   `--LITERAL_NEW -> new [22:17]
        |       |       |           |   |       |--IDENT -> InnerRecord [22:21]
        |       |       |           |   |       |--LPAREN -> ( [22:32]
        |       |       |           |   |       |--ELIST -> ELIST [22:33]
        |       |       |           |   |       |   |--EXPR -> EXPR [22:33]
        |       |       |           |   |       |   |   `--STRING_LITERAL -> "a" [22:33]
        |       |       |           |   |       |   |--COMMA -> , [22:36]
        |       |       |           |   |       |   `--EXPR -> EXPR [22:38]
        |       |       |           |   |       |       `--STRING_LITERAL -> "b" [22:38]
        |       |       |           |   |       `--RPAREN -> ) [22:41]
        |       |       |           |   |--COMMA -> , [22:42]
        |       |       |           |   `--EXPR -> EXPR [22:44]
        |       |       |           |       `--LITERAL_NEW -> new [22:44]
        |       |       |           |           |--IDENT -> InnerRecord [22:48]
        |       |       |           |           |--LPAREN -> ( [22:59]
        |       |       |           |           |--ELIST -> ELIST [22:60]
        |       |       |           |           |   |--EXPR -> EXPR [22:60]
        |       |       |           |           |   |   `--STRING_LITERAL -> "c" [22:60]
        |       |       |           |           |   |--COMMA -> , [22:63]
        |       |       |           |           |   `--EXPR -> EXPR [22:65]
        |       |       |           |           |       `--STRING_LITERAL -> "d" [22:65]
        |       |       |           |           `--RPAREN -> ) [22:68]
        |       |       |           `--RPAREN -> ) [22:69]
        |       |       `--RPAREN -> ) [22:70]
        |       |--SEMI -> ; [22:71]
        |       |--LITERAL_FOR -> for [24:9]
        |       |   |--LPAREN -> ( [24:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [24:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [24:14]
        |       |   |   |   |--TYPE -> TYPE [24:14]
        |       |   |   |   |   |--IDENT -> OtherInnerRecord [24:14]
        |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:30]
        |       |   |   |   |       |--GENERIC_START -> < [24:30]
        |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:31]
        |       |   |   |   |       |   `--IDENT -> InnerRecord [24:31]
        |       |   |   |   |       `--GENERIC_END -> > [24:42]
        |       |   |   |   |--LPAREN -> ( [24:43]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:44]
        |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:44]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [24:44]
        |       |   |   |   |   |   |--TYPE -> TYPE [24:44]
        |       |   |   |   |   |   |   `--IDENT -> InnerRecord [24:44]
        |       |   |   |   |   |   `--IDENT -> b [24:56]
        |       |   |   |   |   |--COMMA -> , [24:57]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:59]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [24:59]
        |       |   |   |   |       |--TYPE -> TYPE [24:59]
        |       |   |   |   |       |   `--IDENT -> InnerRecord [24:59]
        |       |   |   |   |       `--IDENT -> c [24:71]
        |       |   |   |   `--RPAREN -> ) [24:72]
        |       |   |   |--COLON -> : [24:74]
        |       |   |   `--EXPR -> EXPR [24:76]
        |       |   |       `--IDENT -> bList [24:76]
        |       |   |--RPAREN -> ) [24:81]
        |       |   `--SLIST -> { [24:83]
        |       |       |--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 -> b [25:32]
        |       |       |       `--RPAREN -> ) [25:33]
        |       |       |--SEMI -> ; [25:34]
        |       |       |--LITERAL_FOR -> for [26:13]
        |       |       |   |--LPAREN -> ( [26:17]
        |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [26:18]
        |       |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [26:18]
        |       |       |   |   |   |--MODIFIERS -> MODIFIERS [26:18]
        |       |       |   |   |   |--TYPE -> TYPE [26:18]
        |       |       |   |   |   |   `--IDENT -> InnerRecord [26:18]
        |       |       |   |   |   |--LPAREN -> ( [26:29]
        |       |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [26:30]
        |       |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [26:30]
        |       |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [26:30]
        |       |       |   |   |   |   |   |--TYPE -> TYPE [26:30]
        |       |       |   |   |   |   |   |   `--IDENT -> String [26:30]
        |       |       |   |   |   |   |   `--IDENT -> a [26:37]
        |       |       |   |   |   |   |--COMMA -> , [26:38]
        |       |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [26:40]
        |       |       |   |   |   |       |--MODIFIERS -> MODIFIERS [26:40]
        |       |       |   |   |   |       |--TYPE -> TYPE [26:40]
        |       |       |   |   |   |       |   `--IDENT -> String [26:40]
        |       |       |   |   |   |       `--IDENT -> b1 [26:47]
        |       |       |   |   |   `--RPAREN -> ) [26:49]
        |       |       |   |   |--COLON -> : [26:51]
        |       |       |   |   `--EXPR -> EXPR [26:60]
        |       |       |   |       `--METHOD_CALL -> ( [26:60]
        |       |       |   |           |--DOT -> . [26:57]
        |       |       |   |           |   |--IDENT -> List [26:53]
        |       |       |   |           |   `--IDENT -> of [26:58]
        |       |       |   |           |--ELIST -> ELIST [26:61]
        |       |       |   |           |   `--EXPR -> EXPR [26:61]
        |       |       |   |           |       `--IDENT -> c [26:61]
        |       |       |   |           `--RPAREN -> ) [26:62]
        |       |       |   |--RPAREN -> ) [26:63]
        |       |       |   `--SLIST -> { [26:65]
        |       |       |       `--RCURLY -> } [26:66]
        |       |       `--RCURLY -> } [27:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [29:9]
        |       |   |--MODIFIERS -> MODIFIERS [29:9]
        |       |   |--TYPE -> TYPE [29:9]
        |       |   |   |--IDENT -> List [29:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:13]
        |       |   |       |--GENERIC_START -> < [29:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:14]
        |       |   |       |   |--IDENT -> OtherInnerRecord [29:14]
        |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:30]
        |       |   |       |       |--GENERIC_START -> < [29:30]
        |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:31]
        |       |   |       |       |   |--IDENT -> OtherInnerRecord [29:31]
        |       |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:47]
        |       |   |       |       |       |--GENERIC_START -> < [29:47]
        |       |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:48]
        |       |   |       |       |       |   |--IDENT -> OtherInnerRecord [29:48]
        |       |   |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:64]
        |       |   |       |       |       |       |--GENERIC_START -> < [29:64]
        |       |   |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:65]
        |       |   |       |       |       |       |   `--IDENT -> InnerRecord [29:65]
        |       |   |       |       |       |       `--GENERIC_END -> > [29:76]
        |       |   |       |       |       `--GENERIC_END -> > [29:77]
        |       |   |       |       `--GENERIC_END -> > [29:78]
        |       |   |       `--GENERIC_END -> > [29:79]
        |       |   |--IDENT -> cList [30:17]
        |       |   `--ASSIGN -> = [30:23]
        |       |       `--EXPR -> EXPR [30:25]
        |       |           `--LITERAL_NEW -> new [30:25]
        |       |               |--IDENT -> ArrayList [30:29]
        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:38]
        |       |               |   |--GENERIC_START -> < [30:38]
        |       |               |   `--GENERIC_END -> > [30:39]
        |       |               |--LPAREN -> ( [30:40]
        |       |               |--ELIST -> ELIST [30:41]
        |       |               |   `--EXPR -> EXPR [30:41]
        |       |               |       `--NUM_INT -> 1 [30:41]
        |       |               `--RPAREN -> ) [30:42]
        |       |--SEMI -> ; [30:43]
        |       |--EXPR -> EXPR [31:18]
        |       |   `--METHOD_CALL -> ( [31:18]
        |       |       |--DOT -> . [31:14]
        |       |       |   |--IDENT -> cList [31:9]
        |       |       |   `--IDENT -> add [31:15]
        |       |       |--ELIST -> ELIST [31:19]
        |       |       |   `--EXPR -> EXPR [31:19]
        |       |       |       `--LITERAL_NEW -> new [31:19]
        |       |       |           |--IDENT -> OtherInnerRecord [31:23]
        |       |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:39]
        |       |       |           |   |--GENERIC_START -> < [31:39]
        |       |       |           |   `--GENERIC_END -> > [31:40]
        |       |       |           |--LPAREN -> ( [31:41]
        |       |       |           |--ELIST -> ELIST [32:17]
        |       |       |           |   |--EXPR -> EXPR [32:17]
        |       |       |           |   |   `--LITERAL_NEW -> new [32:17]
        |       |       |           |   |       |--IDENT -> OtherInnerRecord [32:21]
        |       |       |           |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:37]
        |       |       |           |   |       |   |--GENERIC_START -> < [32:37]
        |       |       |           |   |       |   `--GENERIC_END -> > [32:38]
        |       |       |           |   |       |--LPAREN -> ( [32:39]
        |       |       |           |   |       |--ELIST -> ELIST [33:25]
        |       |       |           |   |       |   |--EXPR -> EXPR [33:25]
        |       |       |           |   |       |   |   `--LITERAL_NEW -> new [33:25]
        |       |       |           |   |       |   |       |--IDENT -> OtherInnerRecord [33:29]
        |       |       |           |   |       |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [33:45]
        |       |       |           |   |       |   |       |   |--GENERIC_START -> < [33:45]
        |       |       |           |   |       |   |       |   `--GENERIC_END -> > [33:46]
        |       |       |           |   |       |   |       |--LPAREN -> ( [33:47]
        |       |       |           |   |       |   |       |--ELIST -> ELIST [34:33]
        |       |       |           |   |       |   |       |   |--EXPR -> EXPR [34:33]
        |       |       |           |   |       |   |       |   |   `--LITERAL_NEW -> new [34:33]
        |       |       |           |   |       |   |       |   |       |--IDENT -> InnerRecord [34:37]
        |       |       |           |   |       |   |       |   |       |--LPAREN -> ( [34:48]
        |       |       |           |   |       |   |       |   |       |--ELIST -> ELIST [34:49]
        |       |       |           |   |       |   |       |   |       |   |--EXPR -> EXPR [34:49]
        |       |       |           |   |       |   |       |   |       |   |   `--STRING_LITERAL -> "a" [34:49]
        |       |       |           |   |       |   |       |   |       |   |--COMMA -> , [34:52]
        |       |       |           |   |       |   |       |   |       |   `--EXPR -> EXPR [34:54]
        |       |       |           |   |       |   |       |   |       |       `--STRING_LITERAL -> "b" [34:54]
        |       |       |           |   |       |   |       |   |       `--RPAREN -> ) [34:57]
        |       |       |           |   |       |   |       |   |--COMMA -> , [34:58]
        |       |       |           |   |       |   |       |   `--EXPR -> EXPR [35:33]
        |       |       |           |   |       |   |       |       `--LITERAL_NEW -> new [35:33]
        |       |       |           |   |       |   |       |           |--IDENT -> InnerRecord [35:37]
        |       |       |           |   |       |   |       |           |--LPAREN -> ( [35:48]
        |       |       |           |   |       |   |       |           |--ELIST -> ELIST [35:49]
        |       |       |           |   |       |   |       |           |   |--EXPR -> EXPR [35:49]
        |       |       |           |   |       |   |       |           |   |   `--STRING_LITERAL -> "c" [35:49]
        |       |       |           |   |       |   |       |           |   |--COMMA -> , [35:52]
        |       |       |           |   |       |   |       |           |   `--EXPR -> EXPR [35:54]
        |       |       |           |   |       |   |       |           |       `--STRING_LITERAL -> "d" [35:54]
        |       |       |           |   |       |   |       |           `--RPAREN -> ) [35:57]
        |       |       |           |   |       |   |       `--RPAREN -> ) [35:58]
        |       |       |           |   |       |   |--COMMA -> , [35:59]
        |       |       |           |   |       |   `--EXPR -> EXPR [36:25]
        |       |       |           |   |       |       `--LITERAL_NEW -> new [36:25]
        |       |       |           |   |       |           |--IDENT -> OtherInnerRecord [36:29]
        |       |       |           |   |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:45]
        |       |       |           |   |       |           |   |--GENERIC_START -> < [36:45]
        |       |       |           |   |       |           |   `--GENERIC_END -> > [36:46]
        |       |       |           |   |       |           |--LPAREN -> ( [36:47]
        |       |       |           |   |       |           |--ELIST -> ELIST [37:33]
        |       |       |           |   |       |           |   |--EXPR -> EXPR [37:33]
        |       |       |           |   |       |           |   |   `--LITERAL_NEW -> new [37:33]
        |       |       |           |   |       |           |   |       |--IDENT -> InnerRecord [37:37]
        |       |       |           |   |       |           |   |       |--LPAREN -> ( [37:48]
        |       |       |           |   |       |           |   |       |--ELIST -> ELIST [37:49]
        |       |       |           |   |       |           |   |       |   |--EXPR -> EXPR [37:49]
        |       |       |           |   |       |           |   |       |   |   `--STRING_LITERAL -> "e" [37:49]
        |       |       |           |   |       |           |   |       |   |--COMMA -> , [37:52]
        |       |       |           |   |       |           |   |       |   `--EXPR -> EXPR [37:54]
        |       |       |           |   |       |           |   |       |       `--STRING_LITERAL -> "f" [37:54]
        |       |       |           |   |       |           |   |       `--RPAREN -> ) [37:57]
        |       |       |           |   |       |           |   |--COMMA -> , [37:58]
        |       |       |           |   |       |           |   `--EXPR -> EXPR [38:33]
        |       |       |           |   |       |           |       `--LITERAL_NEW -> new [38:33]
        |       |       |           |   |       |           |           |--IDENT -> InnerRecord [38:37]
        |       |       |           |   |       |           |           |--LPAREN -> ( [38:48]
        |       |       |           |   |       |           |           |--ELIST -> ELIST [38:49]
        |       |       |           |   |       |           |           |   |--EXPR -> EXPR [38:49]
        |       |       |           |   |       |           |           |   |   `--STRING_LITERAL -> "g" [38:49]
        |       |       |           |   |       |           |           |   |--COMMA -> , [38:52]
        |       |       |           |   |       |           |           |   `--EXPR -> EXPR [38:54]
        |       |       |           |   |       |           |           |       `--STRING_LITERAL -> "h" [38:54]
        |       |       |           |   |       |           |           `--RPAREN -> ) [38:57]
        |       |       |           |   |       |           `--RPAREN -> ) [38:58]
        |       |       |           |   |       `--RPAREN -> ) [38:59]
        |       |       |           |   |--COMMA -> , [38:60]
        |       |       |           |   `--EXPR -> EXPR [39:17]
        |       |       |           |       `--LITERAL_NEW -> new [39:17]
        |       |       |           |           |--IDENT -> OtherInnerRecord [39:21]
        |       |       |           |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:37]
        |       |       |           |           |   |--GENERIC_START -> < [39:37]
        |       |       |           |           |   `--GENERIC_END -> > [39:38]
        |       |       |           |           |--LPAREN -> ( [39:39]
        |       |       |           |           |--ELIST -> ELIST [40:25]
        |       |       |           |           |   |--EXPR -> EXPR [40:25]
        |       |       |           |           |   |   `--LITERAL_NEW -> new [40:25]
        |       |       |           |           |   |       |--IDENT -> OtherInnerRecord [40:29]
        |       |       |           |           |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:45]
        |       |       |           |           |   |       |   |--GENERIC_START -> < [40:45]
        |       |       |           |           |   |       |   `--GENERIC_END -> > [40:46]
        |       |       |           |           |   |       |--LPAREN -> ( [40:47]
        |       |       |           |           |   |       |--ELIST -> ELIST [41:33]
        |       |       |           |           |   |       |   |--EXPR -> EXPR [41:33]
        |       |       |           |           |   |       |   |   `--LITERAL_NEW -> new [41:33]
        |       |       |           |           |   |       |   |       |--IDENT -> InnerRecord [41:37]
        |       |       |           |           |   |       |   |       |--LPAREN -> ( [41:48]
        |       |       |           |           |   |       |   |       |--ELIST -> ELIST [41:49]
        |       |       |           |           |   |       |   |       |   |--EXPR -> EXPR [41:49]
        |       |       |           |           |   |       |   |       |   |   `--STRING_LITERAL -> "i" [41:49]
        |       |       |           |           |   |       |   |       |   |--COMMA -> , [41:52]
        |       |       |           |           |   |       |   |       |   `--EXPR -> EXPR [41:54]
        |       |       |           |           |   |       |   |       |       `--STRING_LITERAL -> "j" [41:54]
        |       |       |           |           |   |       |   |       `--RPAREN -> ) [41:57]
        |       |       |           |           |   |       |   |--COMMA -> , [41:58]
        |       |       |           |           |   |       |   `--EXPR -> EXPR [42:33]
        |       |       |           |           |   |       |       `--LITERAL_NEW -> new [42:33]
        |       |       |           |           |   |       |           |--IDENT -> InnerRecord [42:37]
        |       |       |           |           |   |       |           |--LPAREN -> ( [42:48]
        |       |       |           |           |   |       |           |--ELIST -> ELIST [42:49]
        |       |       |           |           |   |       |           |   |--EXPR -> EXPR [42:49]
        |       |       |           |           |   |       |           |   |   `--STRING_LITERAL -> "k" [42:49]
        |       |       |           |           |   |       |           |   |--COMMA -> , [42:52]
        |       |       |           |           |   |       |           |   `--EXPR -> EXPR [42:54]
        |       |       |           |           |   |       |           |       `--STRING_LITERAL -> "l" [42:54]
        |       |       |           |           |   |       |           `--RPAREN -> ) [42:57]
        |       |       |           |           |   |       `--RPAREN -> ) [42:58]
        |       |       |           |           |   |--COMMA -> , [42:59]
        |       |       |           |           |   `--EXPR -> EXPR [43:25]
        |       |       |           |           |       `--LITERAL_NEW -> new [43:25]
        |       |       |           |           |           |--IDENT -> OtherInnerRecord [43:29]
        |       |       |           |           |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [43:45]
        |       |       |           |           |           |   |--GENERIC_START -> < [43:45]
        |       |       |           |           |           |   `--GENERIC_END -> > [43:46]
        |       |       |           |           |           |--LPAREN -> ( [43:47]
        |       |       |           |           |           |--ELIST -> ELIST [44:33]
        |       |       |           |           |           |   |--EXPR -> EXPR [44:33]
        |       |       |           |           |           |   |   `--LITERAL_NEW -> new [44:33]
        |       |       |           |           |           |   |       |--IDENT -> InnerRecord [44:37]
        |       |       |           |           |           |   |       |--LPAREN -> ( [44:48]
        |       |       |           |           |           |   |       |--ELIST -> ELIST [44:49]
        |       |       |           |           |           |   |       |   |--EXPR -> EXPR [44:49]
        |       |       |           |           |           |   |       |   |   `--STRING_LITERAL -> "m" [44:49]
        |       |       |           |           |           |   |       |   |--COMMA -> , [44:52]
        |       |       |           |           |           |   |       |   `--EXPR -> EXPR [44:54]
        |       |       |           |           |           |   |       |       `--STRING_LITERAL -> "n" [44:54]
        |       |       |           |           |           |   |       `--RPAREN -> ) [44:57]
        |       |       |           |           |           |   |--COMMA -> , [44:58]
        |       |       |           |           |           |   `--EXPR -> EXPR [45:33]
        |       |       |           |           |           |       `--LITERAL_NEW -> new [45:33]
        |       |       |           |           |           |           |--IDENT -> InnerRecord [45:37]
        |       |       |           |           |           |           |--LPAREN -> ( [45:48]
        |       |       |           |           |           |           |--ELIST -> ELIST [45:49]
        |       |       |           |           |           |           |   |--EXPR -> EXPR [45:49]
        |       |       |           |           |           |           |   |   `--STRING_LITERAL -> "o" [45:49]
        |       |       |           |           |           |           |   |--COMMA -> , [45:52]
        |       |       |           |           |           |           |   `--EXPR -> EXPR [45:54]
        |       |       |           |           |           |           |       `--STRING_LITERAL -> "p" [45:54]
        |       |       |           |           |           |           `--RPAREN -> ) [45:57]
        |       |       |           |           |           `--RPAREN -> ) [46:9]
        |       |       |           |           `--RPAREN -> ) [46:10]
        |       |       |           `--RPAREN -> ) [46:11]
        |       |       `--RPAREN -> ) [46:12]
        |       |--SEMI -> ; [46:13]
        |       |--LITERAL_FOR -> for [48:9]
        |       |   |--LPAREN -> ( [48:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [48:14]
        |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [48:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [48:14]
        |       |   |   |   |--TYPE -> TYPE [48:14]
        |       |   |   |   |   |--IDENT -> OtherInnerRecord [48:14]
        |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:30]
        |       |   |   |   |       |--GENERIC_START -> < [48:30]
        |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:31]
        |       |   |   |   |       |   |--IDENT -> OtherInnerRecord [48:31]
        |       |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:47]
        |       |   |   |   |       |       |--GENERIC_START -> < [48:47]
        |       |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:48]
        |       |   |   |   |       |       |   |--IDENT -> OtherInnerRecord [48:48]
        |       |   |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:64]
        |       |   |   |   |       |       |       |--GENERIC_START -> < [48:64]
        |       |   |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:65]
        |       |   |   |   |       |       |       |   `--IDENT -> InnerRecord [48:65]
        |       |   |   |   |       |       |       `--GENERIC_END -> > [48:76]
        |       |   |   |   |       |       `--GENERIC_END -> > [48:77]
        |       |   |   |   |       `--GENERIC_END -> > [48:78]
        |       |   |   |   |--LPAREN -> ( [49:17]
        |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [49:18]
        |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:18]
        |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [49:18]
        |       |   |   |   |   |   |--TYPE -> TYPE [49:18]
        |       |   |   |   |   |   |   |--IDENT -> OtherInnerRecord [49:18]
        |       |   |   |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:34]
        |       |   |   |   |   |   |       |--GENERIC_START -> < [49:34]
        |       |   |   |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:35]
        |       |   |   |   |   |   |       |   |--IDENT -> OtherInnerRecord [49:35]
        |       |   |   |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:51]
        |       |   |   |   |   |   |       |       |--GENERIC_START -> < [49:51]
        |       |   |   |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:52]
        |       |   |   |   |   |   |       |       |   `--IDENT -> InnerRecord [49:52]
        |       |   |   |   |   |   |       |       `--GENERIC_END -> > [49:63]
        |       |   |   |   |   |   |       `--GENERIC_END -> > [49:64]
        |       |   |   |   |   |   `--IDENT -> b [49:66]
        |       |   |   |   |   |--COMMA -> , [49:67]
        |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:17]
        |       |   |   |   |       |--MODIFIERS -> MODIFIERS [50:17]
        |       |   |   |   |       |--TYPE -> TYPE [50:17]
        |       |   |   |   |       |   |--IDENT -> OtherInnerRecord [50:17]
        |       |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:33]
        |       |   |   |   |       |       |--GENERIC_START -> < [50:33]
        |       |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:34]
        |       |   |   |   |       |       |   |--IDENT -> OtherInnerRecord [50:34]
        |       |   |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:50]
        |       |   |   |   |       |       |       |--GENERIC_START -> < [50:50]
        |       |   |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:51]
        |       |   |   |   |       |       |       |   `--IDENT -> InnerRecord [50:51]
        |       |   |   |   |       |       |       `--GENERIC_END -> > [50:62]
        |       |   |   |   |       |       `--GENERIC_END -> > [50:63]
        |       |   |   |   |       `--IDENT -> c [50:65]
        |       |   |   |   `--RPAREN -> ) [50:66]
        |       |   |   |--COLON -> : [50:68]
        |       |   |   `--EXPR -> EXPR [50:70]
        |       |   |       `--IDENT -> cList [50:70]
        |       |   |--RPAREN -> ) [50:75]
        |       |   `--SLIST -> { [50:77]
        |       |       |--EXPR -> EXPR [51:31]
        |       |       |   `--METHOD_CALL -> ( [51:31]
        |       |       |       |--DOT -> . [51:23]
        |       |       |       |   |--DOT -> . [51:19]
        |       |       |       |   |   |--IDENT -> System [51:13]
        |       |       |       |   |   `--IDENT -> out [51:20]
        |       |       |       |   `--IDENT -> println [51:24]
        |       |       |       |--ELIST -> ELIST [51:32]
        |       |       |       |   `--EXPR -> EXPR [51:32]
        |       |       |       |       `--IDENT -> b [51:32]
        |       |       |       `--RPAREN -> ) [51:33]
        |       |       |--SEMI -> ; [51:34]
        |       |       |--LITERAL_FOR -> for [52:13]
        |       |       |   |--LPAREN -> ( [52:17]
        |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [52:18]
        |       |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [52:18]
        |       |       |   |   |   |--MODIFIERS -> MODIFIERS [52:18]
        |       |       |   |   |   |--TYPE -> TYPE [52:18]
        |       |       |   |   |   |   |--IDENT -> OtherInnerRecord [52:18]
        |       |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [52:34]
        |       |       |   |   |   |       |--GENERIC_START -> < [52:34]
        |       |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [52:35]
        |       |       |   |   |   |       |   |--IDENT -> OtherInnerRecord [52:35]
        |       |       |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [52:51]
        |       |       |   |   |   |       |       |--GENERIC_START -> < [52:51]
        |       |       |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [52:52]
        |       |       |   |   |   |       |       |   `--IDENT -> InnerRecord [52:52]
        |       |       |   |   |   |       |       `--GENERIC_END -> > [52:63]
        |       |       |   |   |   |       `--GENERIC_END -> > [52:64]
        |       |       |   |   |   |--LPAREN -> ( [53:21]
        |       |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [53:22]
        |       |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [53:22]
        |       |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [53:22]
        |       |       |   |   |   |   |   |--TYPE -> TYPE [53:22]
        |       |       |   |   |   |   |   |   |--IDENT -> OtherInnerRecord [53:22]
        |       |       |   |   |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [53:38]
        |       |       |   |   |   |   |   |       |--GENERIC_START -> < [53:38]
        |       |       |   |   |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [53:39]
        |       |       |   |   |   |   |   |       |   `--IDENT -> InnerRecord [53:39]
        |       |       |   |   |   |   |   |       `--GENERIC_END -> > [53:50]
        |       |       |   |   |   |   |   `--IDENT -> b1 [53:52]
        |       |       |   |   |   |   |--COMMA -> , [53:54]
        |       |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:21]
        |       |       |   |   |   |       |--MODIFIERS -> MODIFIERS [54:21]
        |       |       |   |   |   |       |--TYPE -> TYPE [54:21]
        |       |       |   |   |   |       |   |--IDENT -> OtherInnerRecord [54:21]
        |       |       |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [54:37]
        |       |       |   |   |   |       |       |--GENERIC_START -> < [54:37]
        |       |       |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [54:38]
        |       |       |   |   |   |       |       |   `--IDENT -> InnerRecord [54:38]
        |       |       |   |   |   |       |       `--GENERIC_END -> > [54:49]
        |       |       |   |   |   |       `--IDENT -> c1 [54:51]
        |       |       |   |   |   `--RPAREN -> ) [54:53]
        |       |       |   |   |--COLON -> : [54:55]
        |       |       |   |   `--EXPR -> EXPR [54:64]
        |       |       |   |       `--METHOD_CALL -> ( [54:64]
        |       |       |   |           |--DOT -> . [54:61]
        |       |       |   |           |   |--IDENT -> List [54:57]
        |       |       |   |           |   `--IDENT -> of [54:62]
        |       |       |   |           |--ELIST -> ELIST [54:65]
        |       |       |   |           |   `--EXPR -> EXPR [54:65]
        |       |       |   |           |       `--IDENT -> c [54:65]
        |       |       |   |           `--RPAREN -> ) [54:66]
        |       |       |   |--RPAREN -> ) [54:67]
        |       |       |   `--SLIST -> { [54:69]
        |       |       |       |--EXPR -> EXPR [55:35]
        |       |       |       |   `--METHOD_CALL -> ( [55:35]
        |       |       |       |       |--DOT -> . [55:27]
        |       |       |       |       |   |--DOT -> . [55:23]
        |       |       |       |       |   |   |--IDENT -> System [55:17]
        |       |       |       |       |   |   `--IDENT -> out [55:24]
        |       |       |       |       |   `--IDENT -> println [55:28]
        |       |       |       |       |--ELIST -> ELIST [55:36]
        |       |       |       |       |   `--EXPR -> EXPR [55:36]
        |       |       |       |       |       `--IDENT -> b1 [55:36]
        |       |       |       |       `--RPAREN -> ) [55:38]
        |       |       |       |--SEMI -> ; [55:39]
        |       |       |       |--LITERAL_FOR -> for [56:17]
        |       |       |       |   |--LPAREN -> ( [56:21]
        |       |       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [56:22]
        |       |       |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [56:22]
        |       |       |       |   |   |   |--MODIFIERS -> MODIFIERS [56:22]
        |       |       |       |   |   |   |--TYPE -> TYPE [56:22]
        |       |       |       |   |   |   |   |--IDENT -> OtherInnerRecord [56:22]
        |       |       |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:38]
        |       |       |       |   |   |   |       |--GENERIC_START -> < [56:38]
        |       |       |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:39]
        |       |       |       |   |   |   |       |   `--IDENT -> InnerRecord [56:39]
        |       |       |       |   |   |   |       `--GENERIC_END -> > [56:50]
        |       |       |       |   |   |   |--LPAREN -> ( [56:51]
        |       |       |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [56:52]
        |       |       |       |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:52]
        |       |       |       |   |   |   |   |   |--MODIFIERS -> MODIFIERS [56:52]
        |       |       |       |   |   |   |   |   |--TYPE -> TYPE [56:52]
        |       |       |       |   |   |   |   |   |   `--IDENT -> InnerRecord [56:52]
        |       |       |       |   |   |   |   |   `--IDENT -> i [56:64]
        |       |       |       |   |   |   |   |--COMMA -> , [56:65]
        |       |       |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:67]
        |       |       |       |   |   |   |       |--MODIFIERS -> MODIFIERS [56:67]
        |       |       |       |   |   |   |       |--TYPE -> TYPE [56:67]
        |       |       |       |   |   |   |       |   `--IDENT -> InnerRecord [56:67]
        |       |       |       |   |   |   |       `--IDENT -> j [56:79]
        |       |       |       |   |   |   `--RPAREN -> ) [56:80]
        |       |       |       |   |   |--COLON -> : [56:82]
        |       |       |       |   |   `--EXPR -> EXPR [56:91]
        |       |       |       |   |       `--METHOD_CALL -> ( [56:91]
        |       |       |       |   |           |--DOT -> . [56:88]
        |       |       |       |   |           |   |--IDENT -> List [56:84]
        |       |       |       |   |           |   `--IDENT -> of [56:89]
        |       |       |       |   |           |--ELIST -> ELIST [56:92]
        |       |       |       |   |           |   `--EXPR -> EXPR [56:92]
        |       |       |       |   |           |       `--IDENT -> c1 [56:92]
        |       |       |       |   |           `--RPAREN -> ) [56:94]
        |       |       |       |   |--RPAREN -> ) [56:95]
        |       |       |       |   `--SLIST -> { [56:97]
        |       |       |       |       `--RCURLY -> } [56:98]
        |       |       |       `--RCURLY -> } [57:13]
        |       |       `--RCURLY -> } [58:9]
        |       `--RCURLY -> } [60:5]
        `--RCURLY -> } [61:1]
