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