COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
|--PACKAGE_DEF -> package [2:0]
|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
|   |--DOT -> . [2:47]
|   |   |--DOT -> . [2:39]
|   |   |   |--DOT -> . [2:28]
|   |   |   |   |--DOT -> . [2:22]
|   |   |   |   |   |--DOT -> . [2:11]
|   |   |   |   |   |   |--IDENT -> com [2:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:12]
|   |   |   |   |   `--IDENT -> tools [2:23]
|   |   |   |   `--IDENT -> checkstyle [2:29]
|   |   |   `--IDENT -> grammar [2:40]
|   |   `--IDENT -> java19 [2:48]
|   `--SEMI -> ; [2:54]
`--CLASS_DEF -> CLASS_DEF [4:0]
    |--MODIFIERS -> MODIFIERS [4:0]
    |   `--LITERAL_PUBLIC -> public [4:0]
    |--LITERAL_CLASS -> class [4:7]
    |--IDENT -> InputRecordPatternsPreview [4:13]
    `--OBJBLOCK -> OBJBLOCK [4:40]
        |--LCURLY -> { [4:40]
        |--RECORD_DEF -> RECORD_DEF [5:4]
        |   |--MODIFIERS -> MODIFIERS [5:4]
        |   |--LITERAL_RECORD -> record [5:4]
        |   |--IDENT -> Box [5:11]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [5:14]
        |   |   |--GENERIC_START -> < [5:14]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [5:15]
        |   |   |   `--IDENT -> T [5:15]
        |   |   `--GENERIC_END -> > [5:16]
        |   |--LPAREN -> ( [5:17]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [5:18]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [5:18]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [5:18]
        |   |       |--TYPE -> TYPE [5:18]
        |   |       |   `--IDENT -> T [5:18]
        |   |       `--IDENT -> t [5:20]
        |   |--RPAREN -> ) [5:21]
        |   `--OBJBLOCK -> OBJBLOCK [5:23]
        |       |--LCURLY -> { [5:23]
        |       `--RCURLY -> } [6:4]
        |--CLASS_DEF -> CLASS_DEF [8:4]
        |   |--MODIFIERS -> MODIFIERS [8:4]
        |   |--LITERAL_CLASS -> class [8:4]
        |   |--IDENT -> A [8:10]
        |   `--OBJBLOCK -> OBJBLOCK [8:12]
        |       |--LCURLY -> { [8:12]
        |       `--RCURLY -> } [9:4]
        |--CLASS_DEF -> CLASS_DEF [11:4]
        |   |--MODIFIERS -> MODIFIERS [11:4]
        |   |--LITERAL_CLASS -> class [11:4]
        |   |--IDENT -> B [11:10]
        |   |--EXTENDS_CLAUSE -> extends [11:12]
        |   |   `--IDENT -> A [11:20]
        |   `--OBJBLOCK -> OBJBLOCK [11:22]
        |       |--LCURLY -> { [11:22]
        |       `--RCURLY -> } [12:4]
        |--INTERFACE_DEF -> INTERFACE_DEF [14:4]
        |   |--MODIFIERS -> MODIFIERS [14:4]
        |   |   `--LITERAL_SEALED -> sealed [14:4]
        |   |--LITERAL_INTERFACE -> interface [14:11]
        |   |--IDENT -> I [14:21]
        |   |--PERMITS_CLAUSE -> permits [14:23]
        |   |   |--IDENT -> C [14:31]
        |   |   |--COMMA -> , [14:32]
        |   |   `--IDENT -> D [14:34]
        |   `--OBJBLOCK -> OBJBLOCK [14:36]
        |       |--LCURLY -> { [14:36]
        |       `--RCURLY -> } [15:4]
        |--CLASS_DEF -> CLASS_DEF [17:4]
        |   |--MODIFIERS -> MODIFIERS [17:4]
        |   |   `--FINAL -> final [17:4]
        |   |--LITERAL_CLASS -> class [17:10]
        |   |--IDENT -> C [17:16]
        |   |--IMPLEMENTS_CLAUSE -> implements [17:18]
        |   |   `--IDENT -> I [17:29]
        |   `--OBJBLOCK -> OBJBLOCK [17:31]
        |       |--LCURLY -> { [17:31]
        |       `--RCURLY -> } [18:4]
        |--CLASS_DEF -> CLASS_DEF [20:4]
        |   |--MODIFIERS -> MODIFIERS [20:4]
        |   |   `--FINAL -> final [20:4]
        |   |--LITERAL_CLASS -> class [20:10]
        |   |--IDENT -> D [20:16]
        |   |--IMPLEMENTS_CLAUSE -> implements [20:18]
        |   |   `--IDENT -> I [20:29]
        |   `--OBJBLOCK -> OBJBLOCK [20:31]
        |       |--LCURLY -> { [20:31]
        |       `--RCURLY -> } [21:4]
        |--RECORD_DEF -> RECORD_DEF [23:4]
        |   |--MODIFIERS -> MODIFIERS [23:4]
        |   |--LITERAL_RECORD -> record [23:4]
        |   |--IDENT -> Pair [23:11]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [23:15]
        |   |   |--GENERIC_START -> < [23:15]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:16]
        |   |   |   `--IDENT -> T [23:16]
        |   |   `--GENERIC_END -> > [23:17]
        |   |--LPAREN -> ( [23:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [23:19]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:19]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [23:19]
        |   |   |   |--TYPE -> TYPE [23:19]
        |   |   |   |   `--IDENT -> T [23:19]
        |   |   |   `--IDENT -> x [23:21]
        |   |   |--COMMA -> , [23:22]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:24]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [23:24]
        |   |       |--TYPE -> TYPE [23:24]
        |   |       |   `--IDENT -> T [23:24]
        |   |       `--IDENT -> y [23:26]
        |   |--RPAREN -> ) [23:27]
        |   `--OBJBLOCK -> OBJBLOCK [23:29]
        |       |--LCURLY -> { [23:29]
        |       `--RCURLY -> } [24:4]
        |--RECORD_DEF -> RECORD_DEF [26:4]
        |   |--MODIFIERS -> MODIFIERS [26:4]
        |   |--LITERAL_RECORD -> record [26:4]
        |   |--IDENT -> Tuple [26:11]
        |   |--LPAREN -> ( [26:16]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [26:17]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:17]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:17]
        |   |   |   |--TYPE -> TYPE [26:17]
        |   |   |   |   `--IDENT -> Object [26:17]
        |   |   |   `--IDENT -> o1 [26:24]
        |   |   |--COMMA -> , [26:26]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:28]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:28]
        |   |   |   |--TYPE -> TYPE [26:28]
        |   |   |   |   `--IDENT -> Object [26:28]
        |   |   |   `--IDENT -> o2 [26:35]
        |   |   |--COMMA -> , [26:37]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:39]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [26:39]
        |   |       |--TYPE -> TYPE [26:39]
        |   |       |   `--IDENT -> Object [26:39]
        |   |       `--IDENT -> o3 [26:46]
        |   |--RPAREN -> ) [26:48]
        |   `--OBJBLOCK -> OBJBLOCK [26:50]
        |       |--LCURLY -> { [26:50]
        |       `--RCURLY -> } [26:51]
        |--RECORD_DEF -> RECORD_DEF [27:4]
        |   |--MODIFIERS -> MODIFIERS [27:4]
        |   |--LITERAL_RECORD -> record [27:4]
        |   |--IDENT -> VarArgs [27:11]
        |   |--LPAREN -> ( [27:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [27:19]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [27:19]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [27:19]
        |   |       |--TYPE -> TYPE [27:19]
        |   |       |   `--IDENT -> Object [27:19]
        |   |       |--ELLIPSIS -> ... [27:25]
        |   |       `--IDENT -> objArgs [27:29]
        |   |--RPAREN -> ) [27:36]
        |   `--OBJBLOCK -> OBJBLOCK [27:37]
        |       |--LCURLY -> { [27:37]
        |       `--RCURLY -> } [27:38]
        |--METHOD_DEF -> METHOD_DEF [30:4]
        |   |--MODIFIERS -> MODIFIERS [30:4]
        |   |   `--LITERAL_STATIC -> static [30:4]
        |   |--TYPE -> TYPE [30:11]
        |   |   `--LITERAL_VOID -> void [30:11]
        |   |--IDENT -> test1 [30:16]
        |   |--LPAREN -> ( [30:21]
        |   |--PARAMETERS -> PARAMETERS [30:22]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [30:22]
        |   |       |--MODIFIERS -> MODIFIERS [30:22]
        |   |       |--TYPE -> TYPE [30:22]
        |   |       |   |--IDENT -> Box [30:22]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:25]
        |   |       |       |--GENERIC_START -> < [30:25]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:26]
        |   |       |       |   `--IDENT -> Object [30:26]
        |   |       |       `--GENERIC_END -> > [30:32]
        |   |       `--IDENT -> bo [30:34]
        |   |--RPAREN -> ) [30:36]
        |   `--SLIST -> { [30:38]
        |       |--LITERAL_IF -> if [31:8]
        |       |   |--LPAREN -> ( [31:11]
        |       |   |--EXPR -> EXPR [31:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [31:15]
        |       |   |       |--IDENT -> bo [31:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [31:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [31:26]
        |       |   |           |--TYPE -> TYPE [31:26]
        |       |   |           |   |--IDENT -> Box [31:26]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:29]
        |       |   |           |       |--GENERIC_START -> < [31:29]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:30]
        |       |   |           |       |   `--IDENT -> Object [31:30]
        |       |   |           |       `--GENERIC_END -> > [31:36]
        |       |   |           |--LPAREN -> ( [31:37]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [31:38]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:38]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [31:38]
        |       |   |           |       |--TYPE -> TYPE [31:38]
        |       |   |           |       |   `--IDENT -> String [31:38]
        |       |   |           |       `--IDENT -> s [31:45]
        |       |   |           `--RPAREN -> ) [31:46]
        |       |   |--RPAREN -> ) [31:47]
        |       |   `--SLIST -> { [31:49]
        |       |       |--EXPR -> EXPR [32:30]
        |       |       |   `--METHOD_CALL -> ( [32:30]
        |       |       |       |--DOT -> . [32:22]
        |       |       |       |   |--DOT -> . [32:18]
        |       |       |       |   |   |--IDENT -> System [32:12]
        |       |       |       |   |   `--IDENT -> out [32:19]
        |       |       |       |   `--IDENT -> println [32:23]
        |       |       |       |--ELIST -> ELIST [32:41]
        |       |       |       |   `--EXPR -> EXPR [32:41]
        |       |       |       |       `--PLUS -> + [32:41]
        |       |       |       |           |--STRING_LITERAL -> "String " [32:31]
        |       |       |       |           `--IDENT -> s [32:43]
        |       |       |       `--RPAREN -> ) [32:44]
        |       |       |--SEMI -> ; [32:45]
        |       |       `--RCURLY -> } [33:8]
        |       `--RCURLY -> } [34:4]
        |--METHOD_DEF -> METHOD_DEF [36:4]
        |   |--MODIFIERS -> MODIFIERS [36:4]
        |   |   `--LITERAL_STATIC -> static [36:4]
        |   |--TYPE -> TYPE [36:11]
        |   |   `--LITERAL_VOID -> void [36:11]
        |   |--IDENT -> test2 [36:16]
        |   |--LPAREN -> ( [36:21]
        |   |--PARAMETERS -> PARAMETERS [36:22]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:22]
        |   |       |--MODIFIERS -> MODIFIERS [36:22]
        |   |       |--TYPE -> TYPE [36:22]
        |   |       |   |--IDENT -> Box [36:22]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:25]
        |   |       |       |--GENERIC_START -> < [36:25]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:26]
        |   |       |       |   `--IDENT -> Object [36:26]
        |   |       |       `--GENERIC_END -> > [36:32]
        |   |       `--IDENT -> bo [36:34]
        |   |--RPAREN -> ) [36:36]
        |   `--SLIST -> { [36:38]
        |       |--LITERAL_IF -> if [37:8]
        |       |   |--LPAREN -> ( [37:11]
        |       |   |--EXPR -> EXPR [37:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [37:15]
        |       |   |       |--IDENT -> bo [37:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [37:26]
        |       |   |           |--TYPE -> TYPE [37:26]
        |       |   |           |   |--IDENT -> Box [37:26]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:29]
        |       |   |           |       |--GENERIC_START -> < [37:29]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:30]
        |       |   |           |       |   `--WILDCARD_TYPE -> ? [37:30]
        |       |   |           |       `--GENERIC_END -> > [37:31]
        |       |   |           |--LPAREN -> ( [37:32]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:33]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:33]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [37:33]
        |       |   |           |       |--TYPE -> TYPE [37:33]
        |       |   |           |       |   `--IDENT -> var [37:33]
        |       |   |           |       `--IDENT -> s [37:37]
        |       |   |           `--RPAREN -> ) [37:38]
        |       |   |--RPAREN -> ) [37:39]
        |       |   `--SLIST -> { [37:41]
        |       |       |--EXPR -> EXPR [38:30]
        |       |       |   `--METHOD_CALL -> ( [38:30]
        |       |       |       |--DOT -> . [38:22]
        |       |       |       |   |--DOT -> . [38:18]
        |       |       |       |   |   |--IDENT -> System [38:12]
        |       |       |       |   |   `--IDENT -> out [38:19]
        |       |       |       |   `--IDENT -> println [38:23]
        |       |       |       |--ELIST -> ELIST [38:41]
        |       |       |       |   `--EXPR -> EXPR [38:41]
        |       |       |       |       `--PLUS -> + [38:41]
        |       |       |       |           |--STRING_LITERAL -> "String " [38:31]
        |       |       |       |           `--IDENT -> s [38:43]
        |       |       |       `--RPAREN -> ) [38:44]
        |       |       |--SEMI -> ; [38:45]
        |       |       `--RCURLY -> } [39:8]
        |       `--RCURLY -> } [40:4]
        |--METHOD_DEF -> METHOD_DEF [42:4]
        |   |--MODIFIERS -> MODIFIERS [42:4]
        |   |--TYPE -> TYPE [42:4]
        |   |   `--LITERAL_VOID -> void [42:4]
        |   |--IDENT -> test3 [42:9]
        |   |--LPAREN -> ( [42:14]
        |   |--PARAMETERS -> PARAMETERS [42:15]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [42:15]
        |   |       |--MODIFIERS -> MODIFIERS [42:15]
        |   |       |--TYPE -> TYPE [42:15]
        |   |       |   |--IDENT -> Box [42:15]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:18]
        |   |       |       |--GENERIC_START -> < [42:18]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:19]
        |   |       |       |   `--IDENT -> I [42:19]
        |   |       |       `--GENERIC_END -> > [42:20]
        |   |       `--IDENT -> bo [42:22]
        |   |--RPAREN -> ) [42:24]
        |   `--SLIST -> { [42:26]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
        |       |   |--MODIFIERS -> MODIFIERS [43:8]
        |       |   |--TYPE -> TYPE [43:8]
        |       |   |   `--IDENT -> C [43:8]
        |       |   |--IDENT -> c [43:10]
        |       |   `--ASSIGN -> = [43:12]
        |       |       `--EXPR -> EXPR [43:14]
        |       |           `--LITERAL_NEW -> new [43:14]
        |       |               |--IDENT -> C [43:18]
        |       |               |--LPAREN -> ( [43:19]
        |       |               |--ELIST -> ELIST [43:20]
        |       |               `--RPAREN -> ) [43:20]
        |       |--SEMI -> ; [43:21]
        |       |--LITERAL_IF -> if [44:8]
        |       |   |--LPAREN -> ( [44:11]
        |       |   |--EXPR -> EXPR [44:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [44:15]
        |       |   |       |--IDENT -> bo [44:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [44:26]
        |       |   |           |--TYPE -> TYPE [44:26]
        |       |   |           |   |--IDENT -> Box [44:26]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:29]
        |       |   |           |       |--GENERIC_START -> < [44:29]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:30]
        |       |   |           |       |   `--IDENT -> I [44:30]
        |       |   |           |       `--GENERIC_END -> > [44:31]
        |       |   |           |--LPAREN -> ( [44:32]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:33]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [44:33]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [44:33]
        |       |   |           |       |--TYPE -> TYPE [44:33]
        |       |   |           |       |   `--IDENT -> var [44:33]
        |       |   |           |       `--IDENT -> s [44:37]
        |       |   |           `--RPAREN -> ) [44:38]
        |       |   |--RPAREN -> ) [44:39]
        |       |   |--SLIST -> { [44:41]
        |       |   |   |--EXPR -> EXPR [45:30]
        |       |   |   |   `--METHOD_CALL -> ( [45:30]
        |       |   |   |       |--DOT -> . [45:22]
        |       |   |   |       |   |--DOT -> . [45:18]
        |       |   |   |       |   |   |--IDENT -> System [45:12]
        |       |   |   |       |   |   `--IDENT -> out [45:19]
        |       |   |   |       |   `--IDENT -> println [45:23]
        |       |   |   |       |--ELIST -> ELIST [45:41]
        |       |   |   |       |   `--EXPR -> EXPR [45:41]
        |       |   |   |       |       `--PLUS -> + [45:41]
        |       |   |   |       |           |--STRING_LITERAL -> "String " [45:31]
        |       |   |   |       |           `--IDENT -> s [45:43]
        |       |   |   |       `--RPAREN -> ) [45:44]
        |       |   |   |--SEMI -> ; [45:45]
        |       |   |   `--RCURLY -> } [46:8]
        |       |   `--LITERAL_ELSE -> else [47:8]
        |       |       `--LITERAL_IF -> if [47:13]
        |       |           |--LPAREN -> ( [47:16]
        |       |           |--EXPR -> EXPR [47:20]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [47:20]
        |       |           |       |--IDENT -> bo [47:17]
        |       |           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:31]
        |       |           |           |--MODIFIERS -> MODIFIERS [47:31]
        |       |           |           |--TYPE -> TYPE [47:31]
        |       |           |           |   `--IDENT -> Box [47:31]
        |       |           |           `--IDENT -> b [47:35]
        |       |           |--RPAREN -> ) [47:36]
        |       |           |--SLIST -> { [47:38]
        |       |           |   `--RCURLY -> } [49:8]
        |       |           `--LITERAL_ELSE -> else [50:8]
        |       |               `--LITERAL_IF -> if [50:13]
        |       |                   |--LPAREN -> ( [50:16]
        |       |                   |--EXPR -> EXPR [50:40]
        |       |                   |   `--LAND -> && [50:40]
        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [50:20]
        |       |                   |       |   |--IDENT -> bo [50:17]
        |       |                   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:31]
        |       |                   |       |       |--MODIFIERS -> MODIFIERS [50:31]
        |       |                   |       |       |--TYPE -> TYPE [50:31]
        |       |                   |       |       |   |--IDENT -> Box [50:31]
        |       |                   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:34]
        |       |                   |       |       |       |--GENERIC_START -> < [50:34]
        |       |                   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:35]
        |       |                   |       |       |       |   `--IDENT -> I [50:35]
        |       |                   |       |       |       `--GENERIC_END -> > [50:36]
        |       |                   |       |       `--IDENT -> b [50:38]
        |       |                   |       `--METHOD_CALL -> ( [50:54]
        |       |                   |           |--DOT -> . [50:47]
        |       |                   |           |   |--DOT -> . [50:45]
        |       |                   |           |   |   |--IDENT -> bo [50:43]
        |       |                   |           |   |   `--IDENT -> t [50:46]
        |       |                   |           |   `--IDENT -> equals [50:48]
        |       |                   |           |--ELIST -> ELIST [50:55]
        |       |                   |           |   `--EXPR -> EXPR [50:55]
        |       |                   |           |       `--IDENT -> c [50:55]
        |       |                   |           `--RPAREN -> ) [50:56]
        |       |                   |--RPAREN -> ) [50:57]
        |       |                   |--SLIST -> { [50:59]
        |       |                   |   `--RCURLY -> } [52:8]
        |       |                   `--LITERAL_ELSE -> else [53:8]
        |       |                       `--LITERAL_IF -> if [53:13]
        |       |                           |--LPAREN -> ( [53:16]
        |       |                           |--EXPR -> EXPR [53:28]
        |       |                           |   `--LAND -> && [53:28]
        |       |                           |       |--NOT_EQUAL -> != [53:20]
        |       |                           |       |   |--IDENT -> bo [53:17]
        |       |                           |       |   `--LITERAL_NULL -> null [53:23]
        |       |                           |       `--METHOD_CALL -> ( [53:42]
        |       |                           |           |--DOT -> . [53:35]
        |       |                           |           |   |--DOT -> . [53:33]
        |       |                           |           |   |   |--IDENT -> bo [53:31]
        |       |                           |           |   |   `--IDENT -> t [53:34]
        |       |                           |           |   `--IDENT -> equals [53:36]
        |       |                           |           |--ELIST -> ELIST [53:43]
        |       |                           |           |   `--EXPR -> EXPR [53:43]
        |       |                           |           |       `--IDENT -> c [53:43]
        |       |                           |           `--RPAREN -> ) [53:44]
        |       |                           |--RPAREN -> ) [53:45]
        |       |                           `--SLIST -> { [53:47]
        |       |                               `--RCURLY -> } [55:8]
        |       `--RCURLY -> } [56:4]
        |--METHOD_DEF -> METHOD_DEF [58:4]
        |   |--MODIFIERS -> MODIFIERS [58:4]
        |   |   `--LITERAL_STATIC -> static [58:4]
        |   |--TYPE -> TYPE [58:11]
        |   |   `--LITERAL_VOID -> void [58:11]
        |   |--IDENT -> test4 [58:16]
        |   |--LPAREN -> ( [58:21]
        |   |--PARAMETERS -> PARAMETERS [58:22]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:22]
        |   |       |--MODIFIERS -> MODIFIERS [58:22]
        |   |       |--TYPE -> TYPE [58:22]
        |   |       |   |--IDENT -> Pair [58:22]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:26]
        |   |       |       |--GENERIC_START -> < [58:26]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:27]
        |   |       |       |   `--IDENT -> I [58:27]
        |   |       |       `--GENERIC_END -> > [58:28]
        |   |       `--IDENT -> p [58:30]
        |   |--RPAREN -> ) [58:31]
        |   `--SLIST -> { [58:33]
        |       |--LITERAL_IF -> if [59:8]
        |       |   |--LPAREN -> ( [59:11]
        |       |   |--EXPR -> EXPR [59:14]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [59:14]
        |       |   |       |--IDENT -> p [59:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [59:25]
        |       |   |           |--MODIFIERS -> MODIFIERS [59:25]
        |       |   |           |--TYPE -> TYPE [59:25]
        |       |   |           |   |--IDENT -> Pair [59:25]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [59:29]
        |       |   |           |       |--GENERIC_START -> < [59:29]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [59:30]
        |       |   |           |       |   `--IDENT -> I [59:30]
        |       |   |           |       `--GENERIC_END -> > [59:31]
        |       |   |           |--LPAREN -> ( [59:32]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [59:33]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:33]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [59:33]
        |       |   |           |   |   |--TYPE -> TYPE [59:33]
        |       |   |           |   |   |   `--IDENT -> C [59:33]
        |       |   |           |   |   `--IDENT -> t1 [59:35]
        |       |   |           |   |--COMMA -> , [59:37]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:39]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [59:39]
        |       |   |           |       |--TYPE -> TYPE [59:39]
        |       |   |           |       |   `--IDENT -> C [59:39]
        |       |   |           |       `--IDENT -> t2 [59:41]
        |       |   |           `--RPAREN -> ) [59:43]
        |       |   |--RPAREN -> ) [59:44]
        |       |   |--SLIST -> { [59:46]
        |       |   |   |--EXPR -> EXPR [60:30]
        |       |   |   |   `--METHOD_CALL -> ( [60:30]
        |       |   |   |       |--DOT -> . [60:22]
        |       |   |   |       |   |--DOT -> . [60:18]
        |       |   |   |       |   |   |--IDENT -> System [60:12]
        |       |   |   |       |   |   `--IDENT -> out [60:19]
        |       |   |   |       |   `--IDENT -> println [60:23]
        |       |   |   |       |--ELIST -> ELIST [60:31]
        |       |   |   |       |   `--EXPR -> EXPR [60:31]
        |       |   |   |       |       `--IDENT -> t2 [60:31]
        |       |   |   |       `--RPAREN -> ) [60:33]
        |       |   |   |--SEMI -> ; [60:34]
        |       |   |   `--RCURLY -> } [61:8]
        |       |   `--LITERAL_ELSE -> else [62:8]
        |       |       `--LITERAL_IF -> if [62:13]
        |       |           |--LPAREN -> ( [62:16]
        |       |           |--EXPR -> EXPR [62:19]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [62:19]
        |       |           |       |--IDENT -> p [62:17]
        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [62:30]
        |       |           |           |--MODIFIERS -> MODIFIERS [62:30]
        |       |           |           |--TYPE -> TYPE [62:30]
        |       |           |           |   |--IDENT -> Pair [62:30]
        |       |           |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [62:34]
        |       |           |           |       |--GENERIC_START -> < [62:34]
        |       |           |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [62:35]
        |       |           |           |       |   `--IDENT -> I [62:35]
        |       |           |           |       `--GENERIC_END -> > [62:36]
        |       |           |           |--LPAREN -> ( [62:37]
        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [62:38]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:38]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [62:38]
        |       |           |           |   |   |--TYPE -> TYPE [62:38]
        |       |           |           |   |   |   `--IDENT -> D [62:38]
        |       |           |           |   |   `--IDENT -> t1 [62:40]
        |       |           |           |   |--COMMA -> , [62:42]
        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:44]
        |       |           |           |       |--MODIFIERS -> MODIFIERS [62:44]
        |       |           |           |       |--TYPE -> TYPE [62:44]
        |       |           |           |       |   `--IDENT -> D [62:44]
        |       |           |           |       `--IDENT -> t2 [62:46]
        |       |           |           `--RPAREN -> ) [62:48]
        |       |           |--RPAREN -> ) [62:49]
        |       |           `--SLIST -> { [62:51]
        |       |               |--EXPR -> EXPR [63:30]
        |       |               |   `--METHOD_CALL -> ( [63:30]
        |       |               |       |--DOT -> . [63:22]
        |       |               |       |   |--DOT -> . [63:18]
        |       |               |       |   |   |--IDENT -> System [63:12]
        |       |               |       |   |   `--IDENT -> out [63:19]
        |       |               |       |   `--IDENT -> println [63:23]
        |       |               |       |--ELIST -> ELIST [63:31]
        |       |               |       |   `--EXPR -> EXPR [63:31]
        |       |               |       |       `--IDENT -> t1 [63:31]
        |       |               |       `--RPAREN -> ) [63:33]
        |       |               |--SEMI -> ; [63:34]
        |       |               `--RCURLY -> } [64:8]
        |       `--RCURLY -> } [65:4]
        |--METHOD_DEF -> METHOD_DEF [67:4]
        |   |--MODIFIERS -> MODIFIERS [67:4]
        |   |   `--LITERAL_STATIC -> static [67:4]
        |   |--TYPE -> TYPE [67:11]
        |   |   `--LITERAL_VOID -> void [67:11]
        |   |--IDENT -> test5 [67:16]
        |   |--LPAREN -> ( [67:21]
        |   |--PARAMETERS -> PARAMETERS [67:22]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [67:22]
        |   |       |--MODIFIERS -> MODIFIERS [67:22]
        |   |       |--TYPE -> TYPE [67:22]
        |   |       |   `--IDENT -> Tuple [67:22]
        |   |       `--IDENT -> t [67:28]
        |   |--RPAREN -> ) [67:29]
        |   `--SLIST -> { [67:31]
        |       |--LITERAL_IF -> if [68:8]
        |       |   |--LPAREN -> ( [68:11]
        |       |   |--EXPR -> EXPR [68:14]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [68:14]
        |       |   |       |--IDENT -> t [68:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [68:25]
        |       |   |           |--MODIFIERS -> MODIFIERS [68:25]
        |       |   |           |--TYPE -> TYPE [68:25]
        |       |   |           |   `--IDENT -> Tuple [68:25]
        |       |   |           |--LPAREN -> ( [68:30]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [68:31]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:31]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [68:31]
        |       |   |           |   |   |--TYPE -> TYPE [68:31]
        |       |   |           |   |   |   `--IDENT -> String [68:31]
        |       |   |           |   |   `--IDENT -> x [68:38]
        |       |   |           |   |--COMMA -> , [68:39]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:41]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [68:41]
        |       |   |           |   |   |--TYPE -> TYPE [68:41]
        |       |   |           |   |   |   `--IDENT -> String [68:41]
        |       |   |           |   |   `--IDENT -> y [68:48]
        |       |   |           |   |--COMMA -> , [68:49]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:51]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [68:51]
        |       |   |           |       |--TYPE -> TYPE [68:51]
        |       |   |           |       |   `--IDENT -> String [68:51]
        |       |   |           |       `--IDENT -> z [68:58]
        |       |   |           `--RPAREN -> ) [68:59]
        |       |   |--RPAREN -> ) [68:60]
        |       |   |--SLIST -> { [68:62]
        |       |   |   |--EXPR -> EXPR [69:30]
        |       |   |   |   `--METHOD_CALL -> ( [69:30]
        |       |   |   |       |--DOT -> . [69:22]
        |       |   |   |       |   |--DOT -> . [69:18]
        |       |   |   |       |   |   |--IDENT -> System [69:12]
        |       |   |   |       |   |   `--IDENT -> out [69:19]
        |       |   |   |       |   `--IDENT -> println [69:23]
        |       |   |   |       |--ELIST -> ELIST [69:37]
        |       |   |   |       |   `--EXPR -> EXPR [69:37]
        |       |   |   |       |       `--PLUS -> + [69:37]
        |       |   |   |       |           |--PLUS -> + [69:33]
        |       |   |   |       |           |   |--IDENT -> x [69:31]
        |       |   |   |       |           |   `--IDENT -> y [69:35]
        |       |   |   |       |           `--IDENT -> z [69:39]
        |       |   |   |       `--RPAREN -> ) [69:40]
        |       |   |   |--SEMI -> ; [69:41]
        |       |   |   `--RCURLY -> } [70:8]
        |       |   `--LITERAL_ELSE -> else [71:8]
        |       |       `--LITERAL_IF -> if [71:13]
        |       |           |--LPAREN -> ( [71:16]
        |       |           |--EXPR -> EXPR [71:19]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [71:19]
        |       |           |       |--IDENT -> t [71:17]
        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [71:30]
        |       |           |           |--MODIFIERS -> MODIFIERS [71:30]
        |       |           |           |--TYPE -> TYPE [71:30]
        |       |           |           |   `--IDENT -> Tuple [71:30]
        |       |           |           |--LPAREN -> ( [71:35]
        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [71:36]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:36]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [71:36]
        |       |           |           |   |   |--TYPE -> TYPE [71:36]
        |       |           |           |   |   |   `--IDENT -> Integer [71:36]
        |       |           |           |   |   `--IDENT -> x [71:44]
        |       |           |           |   |--COMMA -> , [71:45]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:47]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [71:47]
        |       |           |           |   |   |--TYPE -> TYPE [71:47]
        |       |           |           |   |   |   `--IDENT -> Integer [71:47]
        |       |           |           |   |   `--IDENT -> y [71:55]
        |       |           |           |   |--COMMA -> , [71:56]
        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:58]
        |       |           |           |       |--MODIFIERS -> MODIFIERS [71:58]
        |       |           |           |       |--TYPE -> TYPE [71:58]
        |       |           |           |       |   `--IDENT -> Integer [71:58]
        |       |           |           |       `--IDENT -> z [71:66]
        |       |           |           `--RPAREN -> ) [71:67]
        |       |           |--RPAREN -> ) [71:68]
        |       |           `--SLIST -> { [71:70]
        |       |               |--EXPR -> EXPR [72:30]
        |       |               |   `--METHOD_CALL -> ( [72:30]
        |       |               |       |--DOT -> . [72:22]
        |       |               |       |   |--DOT -> . [72:18]
        |       |               |       |   |   |--IDENT -> System [72:12]
        |       |               |       |   |   `--IDENT -> out [72:19]
        |       |               |       |   `--IDENT -> println [72:23]
        |       |               |       |--ELIST -> ELIST [72:37]
        |       |               |       |   `--EXPR -> EXPR [72:37]
        |       |               |       |       `--PLUS -> + [72:37]
        |       |               |       |           |--PLUS -> + [72:33]
        |       |               |       |           |   |--IDENT -> x [72:31]
        |       |               |       |           |   `--IDENT -> y [72:35]
        |       |               |       |           `--IDENT -> z [72:39]
        |       |               |       `--RPAREN -> ) [72:40]
        |       |               |--SEMI -> ; [72:41]
        |       |               `--RCURLY -> } [73:8]
        |       `--RCURLY -> } [74:4]
        |--METHOD_DEF -> METHOD_DEF [76:4]
        |   |--MODIFIERS -> MODIFIERS [76:4]
        |   |   `--LITERAL_STATIC -> static [76:4]
        |   |--TYPE -> TYPE [76:11]
        |   |   `--LITERAL_VOID -> void [76:11]
        |   |--IDENT -> test5 [76:16]
        |   |--LPAREN -> ( [76:21]
        |   |--PARAMETERS -> PARAMETERS [76:22]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [76:22]
        |   |       |--MODIFIERS -> MODIFIERS [76:22]
        |   |       |--TYPE -> TYPE [76:22]
        |   |       |   `--IDENT -> VarArgs [76:22]
        |   |       `--IDENT -> v [76:30]
        |   |--RPAREN -> ) [76:31]
        |   `--SLIST -> { [76:33]
        |       |--LITERAL_IF -> if [77:8]
        |       |   |--LPAREN -> ( [77:11]
        |       |   |--EXPR -> EXPR [77:14]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [77:14]
        |       |   |       |--IDENT -> v [77:12]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [77:25]
        |       |   |           |--MODIFIERS -> MODIFIERS [77:25]
        |       |   |           |--TYPE -> TYPE [77:25]
        |       |   |           |   `--IDENT -> VarArgs [77:25]
        |       |   |           |--LPAREN -> ( [77:32]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [77:33]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [77:33]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [77:33]
        |       |   |           |       |--TYPE -> TYPE [77:33]
        |       |   |           |       |   |--IDENT -> Integer [77:33]
        |       |   |           |       |   `--ARRAY_DECLARATOR -> [ [77:40]
        |       |   |           |       |       `--RBRACK -> ] [77:41]
        |       |   |           |       `--IDENT -> ints [77:43]
        |       |   |           `--RPAREN -> ) [77:47]
        |       |   |--RPAREN -> ) [77:48]
        |       |   |--SLIST -> { [77:50]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [78:12]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [78:12]
        |       |   |   |   |--TYPE -> TYPE [78:12]
        |       |   |   |   |   `--LITERAL_INT -> int [78:12]
        |       |   |   |   |--IDENT -> l [78:16]
        |       |   |   |   `--ASSIGN -> = [78:18]
        |       |   |   |       `--EXPR -> EXPR [78:24]
        |       |   |   |           `--DOT -> . [78:24]
        |       |   |   |               |--IDENT -> ints [78:20]
        |       |   |   |               `--IDENT -> length [78:25]
        |       |   |   |--SEMI -> ; [78:31]
        |       |   |   `--RCURLY -> } [79:8]
        |       |   `--LITERAL_ELSE -> else [80:8]
        |       |       `--LITERAL_IF -> if [80:13]
        |       |           |--LPAREN -> ( [80:16]
        |       |           |--EXPR -> EXPR [81:12]
        |       |           |   `--LAND -> && [81:12]
        |       |           |       |--LITERAL_INSTANCEOF -> instanceof [80:19]
        |       |           |       |   |--IDENT -> v [80:17]
        |       |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [80:30]
        |       |           |       |       |--MODIFIERS -> MODIFIERS [80:30]
        |       |           |       |       |--TYPE -> TYPE [80:30]
        |       |           |       |       |   `--IDENT -> VarArgs [80:30]
        |       |           |       |       |--LPAREN -> ( [80:37]
        |       |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [80:38]
        |       |           |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [80:38]
        |       |           |       |       |       |--MODIFIERS -> MODIFIERS [80:38]
        |       |           |       |       |       |--TYPE -> TYPE [80:38]
        |       |           |       |       |       |   |--IDENT -> Object [80:38]
        |       |           |       |       |       |   `--ARRAY_DECLARATOR -> [ [80:44]
        |       |           |       |       |       |       `--RBRACK -> ] [80:45]
        |       |           |       |       |       `--IDENT -> objects [80:47]
        |       |           |       |       `--RPAREN -> ) [80:54]
        |       |           |       `--GT -> > [81:30]
        |       |           |           |--DOT -> . [81:22]
        |       |           |           |   |--IDENT -> objects [81:15]
        |       |           |           |   `--IDENT -> length [81:23]
        |       |           |           `--NUM_INT -> 2 [81:32]
        |       |           |--RPAREN -> ) [81:33]
        |       |           |--SLIST -> { [81:35]
        |       |           |   |--VARIABLE_DEF -> VARIABLE_DEF [82:12]
        |       |           |   |   |--MODIFIERS -> MODIFIERS [82:12]
        |       |           |   |   |--TYPE -> TYPE [82:12]
        |       |           |   |   |   `--LITERAL_INT -> int [82:12]
        |       |           |   |   |--IDENT -> l [82:16]
        |       |           |   |   `--ASSIGN -> = [82:18]
        |       |           |   |       `--EXPR -> EXPR [82:27]
        |       |           |   |           `--DOT -> . [82:27]
        |       |           |   |               |--IDENT -> objects [82:20]
        |       |           |   |               `--IDENT -> length [82:28]
        |       |           |   |--SEMI -> ; [82:34]
        |       |           |   `--RCURLY -> } [83:8]
        |       |           `--LITERAL_ELSE -> else [84:8]
        |       |               `--LITERAL_IF -> if [84:13]
        |       |                   |--LPAREN -> ( [84:16]
        |       |                   |--EXPR -> EXPR [85:12]
        |       |                   |   `--LAND -> && [85:12]
        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [84:19]
        |       |                   |       |   |--IDENT -> v [84:17]
        |       |                   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [84:30]
        |       |                   |       |       |--MODIFIERS -> MODIFIERS [84:30]
        |       |                   |       |       |--TYPE -> TYPE [84:30]
        |       |                   |       |       |   `--IDENT -> VarArgs [84:30]
        |       |                   |       |       |--LPAREN -> ( [84:37]
        |       |                   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [84:38]
        |       |                   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:38]
        |       |                   |       |       |       |--MODIFIERS -> MODIFIERS [84:38]
        |       |                   |       |       |       |--TYPE -> TYPE [84:38]
        |       |                   |       |       |       |   |--IDENT -> Object [84:38]
        |       |                   |       |       |       |   `--ARRAY_DECLARATOR -> [ [84:44]
        |       |                   |       |       |       |       `--RBRACK -> ] [84:45]
        |       |                   |       |       |       `--IDENT -> objects [84:47]
        |       |                   |       |       `--RPAREN -> ) [84:54]
        |       |                   |       `--LT -> < [85:30]
        |       |                   |           |--DOT -> . [85:22]
        |       |                   |           |   |--IDENT -> objects [85:15]
        |       |                   |           |   `--IDENT -> length [85:23]
        |       |                   |           `--NUM_INT -> 2 [85:32]
        |       |                   |--RPAREN -> ) [85:33]
        |       |                   `--SLIST -> { [85:34]
        |       |                       |--VARIABLE_DEF -> VARIABLE_DEF [86:12]
        |       |                       |   |--MODIFIERS -> MODIFIERS [86:12]
        |       |                       |   |--TYPE -> TYPE [86:12]
        |       |                       |   |   `--LITERAL_INT -> int [86:12]
        |       |                       |   |--IDENT -> l [86:16]
        |       |                       |   `--ASSIGN -> = [86:18]
        |       |                       |       `--EXPR -> EXPR [86:27]
        |       |                       |           `--DOT -> . [86:27]
        |       |                       |               |--IDENT -> objects [86:20]
        |       |                       |               `--IDENT -> length [86:28]
        |       |                       |--SEMI -> ; [86:34]
        |       |                       `--RCURLY -> } [87:8]
        |       `--RCURLY -> } [89:4]
        |--METHOD_DEF -> METHOD_DEF [91:4]
        |   |--MODIFIERS -> MODIFIERS [91:4]
        |   |   `--LITERAL_STATIC -> static [91:4]
        |   |--TYPE -> TYPE [91:11]
        |   |   `--LITERAL_VOID -> void [91:11]
        |   |--IDENT -> m1 [91:16]
        |   |--LPAREN -> ( [91:18]
        |   |--PARAMETERS -> PARAMETERS [91:19]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [91:19]
        |   |       |--MODIFIERS -> MODIFIERS [91:19]
        |   |       |--TYPE -> TYPE [91:19]
        |   |       |   |--IDENT -> Pair [91:19]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [91:23]
        |   |       |       |--GENERIC_START -> < [91:23]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [91:24]
        |   |       |       |   `--IDENT -> I [91:24]
        |   |       |       `--GENERIC_END -> > [91:25]
        |   |       `--IDENT -> p1 [91:27]
        |   |--RPAREN -> ) [91:29]
        |   `--SLIST -> { [91:31]
        |       |--LITERAL_SWITCH -> switch [92:8]
        |       |   |--LPAREN -> ( [92:15]
        |       |   |--EXPR -> EXPR [92:16]
        |       |   |   `--IDENT -> p1 [92:16]
        |       |   |--RPAREN -> ) [92:18]
        |       |   |--LCURLY -> { [92:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [93:12]
        |       |   |   |--LITERAL_CASE -> case [93:12]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [93:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [93:17]
        |       |   |   |       |--TYPE -> TYPE [93:17]
        |       |   |   |       |   |--IDENT -> Pair [93:17]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [93:21]
        |       |   |   |       |       |--GENERIC_START -> < [93:21]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [93:22]
        |       |   |   |       |       |   `--IDENT -> I [93:22]
        |       |   |   |       |       `--GENERIC_END -> > [93:23]
        |       |   |   |       |--LPAREN -> ( [93:24]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [93:25]
        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [93:25]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [93:25]
        |       |   |   |       |   |   |--TYPE -> TYPE [93:25]
        |       |   |   |       |   |   |   `--IDENT -> I [93:25]
        |       |   |   |       |   |   `--IDENT -> i [93:27]
        |       |   |   |       |   |--COMMA -> , [93:28]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [93:29]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [93:29]
        |       |   |   |       |       |--TYPE -> TYPE [93:29]
        |       |   |   |       |       |   `--IDENT -> C [93:29]
        |       |   |   |       |       `--IDENT -> c [93:31]
        |       |   |   |       `--RPAREN -> ) [93:32]
        |       |   |   |--LAMBDA -> -> [93:34]
        |       |   |   |--EXPR -> EXPR [94:38]
        |       |   |   |   `--METHOD_CALL -> ( [94:38]
        |       |   |   |       |--DOT -> . [94:30]
        |       |   |   |       |   |--DOT -> . [94:26]
        |       |   |   |       |   |   |--IDENT -> System [94:20]
        |       |   |   |       |   |   `--IDENT -> out [94:27]
        |       |   |   |       |   `--IDENT -> println [94:31]
        |       |   |   |       |--ELIST -> ELIST [94:39]
        |       |   |   |       |   `--EXPR -> EXPR [94:39]
        |       |   |   |       |       `--STRING_LITERAL -> "C!" [94:39]
        |       |   |   |       `--RPAREN -> ) [94:43]
        |       |   |   `--SEMI -> ; [94:44]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [95:12]
        |       |   |   |--LITERAL_CASE -> case [95:12]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [95:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [95:17]
        |       |   |   |       |--TYPE -> TYPE [95:17]
        |       |   |   |       |   |--IDENT -> Pair [95:17]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [95:21]
        |       |   |   |       |       |--GENERIC_START -> < [95:21]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [95:22]
        |       |   |   |       |       |   `--IDENT -> I [95:22]
        |       |   |   |       |       `--GENERIC_END -> > [95:23]
        |       |   |   |       |--LPAREN -> ( [95:24]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [95:25]
        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [95:25]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [95:25]
        |       |   |   |       |   |   |--TYPE -> TYPE [95:25]
        |       |   |   |       |   |   |   `--IDENT -> I [95:25]
        |       |   |   |       |   |   `--IDENT -> i [95:27]
        |       |   |   |       |   |--COMMA -> , [95:28]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [95:29]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [95:29]
        |       |   |   |       |       |--TYPE -> TYPE [95:29]
        |       |   |   |       |       |   `--IDENT -> D [95:29]
        |       |   |   |       |       `--IDENT -> d [95:31]
        |       |   |   |       `--RPAREN -> ) [95:32]
        |       |   |   |--LAMBDA -> -> [95:34]
        |       |   |   |--EXPR -> EXPR [96:38]
        |       |   |   |   `--METHOD_CALL -> ( [96:38]
        |       |   |   |       |--DOT -> . [96:30]
        |       |   |   |       |   |--DOT -> . [96:26]
        |       |   |   |       |   |   |--IDENT -> System [96:20]
        |       |   |   |       |   |   `--IDENT -> out [96:27]
        |       |   |   |       |   `--IDENT -> println [96:31]
        |       |   |   |       |--ELIST -> ELIST [96:39]
        |       |   |   |       |   `--EXPR -> EXPR [96:39]
        |       |   |   |       |       `--STRING_LITERAL -> "D!" [96:39]
        |       |   |   |       `--RPAREN -> ) [96:43]
        |       |   |   `--SEMI -> ; [96:44]
        |       |   `--RCURLY -> } [97:8]
        |       |--LITERAL_SWITCH -> switch [99:8]
        |       |   |--LPAREN -> ( [99:15]
        |       |   |--EXPR -> EXPR [99:16]
        |       |   |   `--IDENT -> p1 [99:16]
        |       |   |--RPAREN -> ) [99:18]
        |       |   |--LCURLY -> { [99:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [100:12]
        |       |   |   |--LITERAL_CASE -> case [100:12]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [100:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [100:17]
        |       |   |   |       |--TYPE -> TYPE [100:17]
        |       |   |   |       |   |--IDENT -> Pair [100:17]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:21]
        |       |   |   |       |       |--GENERIC_START -> < [100:21]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:22]
        |       |   |   |       |       |   `--IDENT -> I [100:22]
        |       |   |   |       |       `--GENERIC_END -> > [100:23]
        |       |   |   |       |--LPAREN -> ( [100:24]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [100:25]
        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [100:25]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [100:25]
        |       |   |   |       |   |   |--TYPE -> TYPE [100:25]
        |       |   |   |       |   |   |   `--IDENT -> C [100:25]
        |       |   |   |       |   |   `--IDENT -> c [100:27]
        |       |   |   |       |   |--COMMA -> , [100:28]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [100:29]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [100:29]
        |       |   |   |       |       |--TYPE -> TYPE [100:29]
        |       |   |   |       |       |   `--IDENT -> I [100:29]
        |       |   |   |       |       `--IDENT -> i [100:31]
        |       |   |   |       `--RPAREN -> ) [100:32]
        |       |   |   |--LAMBDA -> -> [100:34]
        |       |   |   |--EXPR -> EXPR [101:38]
        |       |   |   |   `--METHOD_CALL -> ( [101:38]
        |       |   |   |       |--DOT -> . [101:30]
        |       |   |   |       |   |--DOT -> . [101:26]
        |       |   |   |       |   |   |--IDENT -> System [101:20]
        |       |   |   |       |   |   `--IDENT -> out [101:27]
        |       |   |   |       |   `--IDENT -> println [101:31]
        |       |   |   |       |--ELIST -> ELIST [101:39]
        |       |   |   |       |   `--EXPR -> EXPR [101:39]
        |       |   |   |       |       `--STRING_LITERAL -> "T!" [101:39]
        |       |   |   |       `--RPAREN -> ) [101:43]
        |       |   |   `--SEMI -> ; [101:44]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [102:12]
        |       |   |   |--LITERAL_CASE -> case [102:12]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [102:17]
        |       |   |   |       |--TYPE -> TYPE [102:17]
        |       |   |   |       |   |--IDENT -> Pair [102:17]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [102:21]
        |       |   |   |       |       |--GENERIC_START -> < [102:21]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [102:22]
        |       |   |   |       |       |   `--IDENT -> I [102:22]
        |       |   |   |       |       `--GENERIC_END -> > [102:23]
        |       |   |   |       |--LPAREN -> ( [102:24]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:25]
        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:25]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [102:25]
        |       |   |   |       |   |   |--TYPE -> TYPE [102:25]
        |       |   |   |       |   |   |   `--IDENT -> D [102:25]
        |       |   |   |       |   |   `--IDENT -> d [102:27]
        |       |   |   |       |   |--COMMA -> , [102:28]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:29]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [102:29]
        |       |   |   |       |       |--TYPE -> TYPE [102:29]
        |       |   |   |       |       |   `--IDENT -> C [102:29]
        |       |   |   |       |       `--IDENT -> c [102:31]
        |       |   |   |       `--RPAREN -> ) [102:32]
        |       |   |   |--LAMBDA -> -> [102:34]
        |       |   |   |--EXPR -> EXPR [103:38]
        |       |   |   |   `--METHOD_CALL -> ( [103:38]
        |       |   |   |       |--DOT -> . [103:30]
        |       |   |   |       |   |--DOT -> . [103:26]
        |       |   |   |       |   |   |--IDENT -> System [103:20]
        |       |   |   |       |   |   `--IDENT -> out [103:27]
        |       |   |   |       |   `--IDENT -> println [103:31]
        |       |   |   |       |--ELIST -> ELIST [103:39]
        |       |   |   |       |   `--EXPR -> EXPR [103:39]
        |       |   |   |       |       `--STRING_LITERAL -> "C!" [103:39]
        |       |   |   |       `--RPAREN -> ) [103:43]
        |       |   |   `--SEMI -> ; [103:44]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [104:12]
        |       |   |   |--LITERAL_CASE -> case [104:12]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [104:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [104:17]
        |       |   |   |       |--TYPE -> TYPE [104:17]
        |       |   |   |       |   |--IDENT -> Pair [104:17]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [104:21]
        |       |   |   |       |       |--GENERIC_START -> < [104:21]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [104:22]
        |       |   |   |       |       |   `--IDENT -> I [104:22]
        |       |   |   |       |       `--GENERIC_END -> > [104:23]
        |       |   |   |       |--LPAREN -> ( [104:24]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [104:25]
        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [104:25]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [104:25]
        |       |   |   |       |   |   |--TYPE -> TYPE [104:25]
        |       |   |   |       |   |   |   `--IDENT -> D [104:25]
        |       |   |   |       |   |   `--IDENT -> d1 [104:27]
        |       |   |   |       |   |--COMMA -> , [104:29]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [104:30]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [104:30]
        |       |   |   |       |       |--TYPE -> TYPE [104:30]
        |       |   |   |       |       |   `--IDENT -> D [104:30]
        |       |   |   |       |       `--IDENT -> d2 [104:32]
        |       |   |   |       `--RPAREN -> ) [104:34]
        |       |   |   |--LAMBDA -> -> [104:36]
        |       |   |   |--EXPR -> EXPR [105:38]
        |       |   |   |   `--METHOD_CALL -> ( [105:38]
        |       |   |   |       |--DOT -> . [105:30]
        |       |   |   |       |   |--DOT -> . [105:26]
        |       |   |   |       |   |   |--IDENT -> System [105:20]
        |       |   |   |       |   |   `--IDENT -> out [105:27]
        |       |   |   |       |   `--IDENT -> println [105:31]
        |       |   |   |       |--ELIST -> ELIST [105:39]
        |       |   |   |       |   `--EXPR -> EXPR [105:39]
        |       |   |   |       |       `--STRING_LITERAL -> "D!" [105:39]
        |       |   |   |       `--RPAREN -> ) [105:43]
        |       |   |   `--SEMI -> ; [105:44]
        |       |   `--RCURLY -> } [106:8]
        |       `--RCURLY -> } [107:4]
        |--METHOD_DEF -> METHOD_DEF [109:4]
        |   |--MODIFIERS -> MODIFIERS [109:4]
        |   |--TYPE -> TYPE [109:4]
        |   |   `--IDENT -> String [109:4]
        |   |--IDENT -> m2 [109:11]
        |   |--LPAREN -> ( [109:13]
        |   |--PARAMETERS -> PARAMETERS [109:14]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [109:14]
        |   |       |--MODIFIERS -> MODIFIERS [109:14]
        |   |       |--TYPE -> TYPE [109:14]
        |   |       |   |--IDENT -> Pair [109:14]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [109:18]
        |   |       |       |--GENERIC_START -> < [109:18]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [109:19]
        |   |       |       |   `--IDENT -> I [109:19]
        |   |       |       `--GENERIC_END -> > [109:20]
        |   |       `--IDENT -> p1 [109:22]
        |   |--RPAREN -> ) [109:24]
        |   `--SLIST -> { [109:26]
        |       |--LITERAL_RETURN -> return [110:8]
        |       |   |--EXPR -> EXPR [110:15]
        |       |   |   `--LITERAL_SWITCH -> switch [110:15]
        |       |   |       |--LPAREN -> ( [110:22]
        |       |   |       |--EXPR -> EXPR [110:23]
        |       |   |       |   `--IDENT -> p1 [110:23]
        |       |   |       |--RPAREN -> ) [110:25]
        |       |   |       |--LCURLY -> { [110:27]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [111:12]
        |       |   |       |   |--LITERAL_CASE -> case [111:12]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [111:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [111:17]
        |       |   |       |   |       |--TYPE -> TYPE [111:17]
        |       |   |       |   |       |   |--IDENT -> Pair [111:17]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [111:21]
        |       |   |       |   |       |       |--GENERIC_START -> < [111:21]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [111:22]
        |       |   |       |   |       |       |   `--IDENT -> I [111:22]
        |       |   |       |   |       |       `--GENERIC_END -> > [111:23]
        |       |   |       |   |       |--LPAREN -> ( [111:24]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [111:25]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [111:25]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [111:25]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [111:25]
        |       |   |       |   |       |   |   |   `--IDENT -> C [111:25]
        |       |   |       |   |       |   |   `--IDENT -> c [111:27]
        |       |   |       |   |       |   |--COMMA -> , [111:28]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [111:29]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [111:29]
        |       |   |       |   |       |       |--TYPE -> TYPE [111:29]
        |       |   |       |   |       |       |   `--IDENT -> I [111:29]
        |       |   |       |   |       |       `--IDENT -> i [111:31]
        |       |   |       |   |       `--RPAREN -> ) [111:32]
        |       |   |       |   |--LAMBDA -> -> [111:34]
        |       |   |       |   |--EXPR -> EXPR [111:37]
        |       |   |       |   |   `--STRING_LITERAL -> "T!" [111:37]
        |       |   |       |   `--SEMI -> ; [111:41]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [112:12]
        |       |   |       |   |--LITERAL_CASE -> case [112:12]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [112:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [112:17]
        |       |   |       |   |       |--TYPE -> TYPE [112:17]
        |       |   |       |   |       |   |--IDENT -> Pair [112:17]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [112:21]
        |       |   |       |   |       |       |--GENERIC_START -> < [112:21]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [112:22]
        |       |   |       |   |       |       |   `--IDENT -> I [112:22]
        |       |   |       |   |       |       `--GENERIC_END -> > [112:23]
        |       |   |       |   |       |--LPAREN -> ( [112:24]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [112:25]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:25]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [112:25]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [112:25]
        |       |   |       |   |       |   |   |   `--IDENT -> D [112:25]
        |       |   |       |   |       |   |   `--IDENT -> d [112:27]
        |       |   |       |   |       |   |--COMMA -> , [112:28]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:29]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [112:29]
        |       |   |       |   |       |       |--TYPE -> TYPE [112:29]
        |       |   |       |   |       |       |   `--IDENT -> C [112:29]
        |       |   |       |   |       |       `--IDENT -> c [112:31]
        |       |   |       |   |       `--RPAREN -> ) [112:32]
        |       |   |       |   |--LAMBDA -> -> [112:34]
        |       |   |       |   |--EXPR -> EXPR [112:37]
        |       |   |       |   |   `--STRING_LITERAL -> "C!" [112:37]
        |       |   |       |   `--SEMI -> ; [112:41]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [113:12]
        |       |   |       |   |--LITERAL_CASE -> case [113:12]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [113:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [113:17]
        |       |   |       |   |       |--TYPE -> TYPE [113:17]
        |       |   |       |   |       |   |--IDENT -> Pair [113:17]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [113:21]
        |       |   |       |   |       |       |--GENERIC_START -> < [113:21]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [113:22]
        |       |   |       |   |       |       |   `--IDENT -> I [113:22]
        |       |   |       |   |       |       `--GENERIC_END -> > [113:23]
        |       |   |       |   |       |--LPAREN -> ( [113:24]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [113:25]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [113:25]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [113:25]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [113:25]
        |       |   |       |   |       |   |   |   `--IDENT -> D [113:25]
        |       |   |       |   |       |   |   `--IDENT -> d1 [113:27]
        |       |   |       |   |       |   |--COMMA -> , [113:29]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [113:30]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [113:30]
        |       |   |       |   |       |       |--TYPE -> TYPE [113:30]
        |       |   |       |   |       |       |   `--IDENT -> D [113:30]
        |       |   |       |   |       |       `--IDENT -> d2 [113:32]
        |       |   |       |   |       `--RPAREN -> ) [113:34]
        |       |   |       |   |--LAMBDA -> -> [113:36]
        |       |   |       |   |--EXPR -> EXPR [113:39]
        |       |   |       |   |   `--STRING_LITERAL -> "D!" [113:39]
        |       |   |       |   `--SEMI -> ; [113:43]
        |       |   |       `--RCURLY -> } [114:8]
        |       |   `--SEMI -> ; [114:9]
        |       `--RCURLY -> } [115:4]
        `--RCURLY -> } [116:0]
