COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java19 [2:49]
|   `--SEMI -> ; [2:55]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> Objects [4:18]
|   `--SEMI -> ; [4:25]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:26]
|   |   |--DOT -> . [5:17]
|   |   |   |--DOT -> . [5:12]
|   |   |   |   |--IDENT -> java [5:8]
|   |   |   |   `--IDENT -> util [5:13]
|   |   |   `--IDENT -> function [5:18]
|   |   `--IDENT -> Function [5:27]
|   `--SEMI -> ; [5:35]
`--CLASS_DEF -> CLASS_DEF [7:1]
    |--MODIFIERS -> MODIFIERS [7:1]
    |   `--LITERAL_PUBLIC -> public [7:1]
    |--LITERAL_CLASS -> class [7:8]
    |--IDENT -> InputGenericRecordDeconstructionPattern [7:14]
    `--OBJBLOCK -> OBJBLOCK [7:54]
        |--LCURLY -> { [7:54]
        |--METHOD_DEF -> METHOD_DEF [9:5]
        |   |--MODIFIERS -> MODIFIERS [9:5]
        |   |--TYPE -> TYPE [9:5]
        |   |   `--LITERAL_VOID -> void [9:5]
        |   |--IDENT -> m1 [9:10]
        |   |--LPAREN -> ( [9:12]
        |   |--PARAMETERS -> PARAMETERS [9:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [9:13]
        |   |       |--MODIFIERS -> MODIFIERS [9:13]
        |   |       |--TYPE -> TYPE [9:13]
        |   |       |   |--IDENT -> Function [9:13]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [9:21]
        |   |       |       |--GENERIC_START -> < [9:21]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:22]
        |   |       |       |   |--IDENT -> Box [9:22]
        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [9:25]
        |   |       |       |       |--GENERIC_START -> < [9:25]
        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:26]
        |   |       |       |       |   `--IDENT -> String [9:26]
        |   |       |       |       `--GENERIC_END -> > [9:32]
        |   |       |       |--COMMA -> , [9:33]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:35]
        |   |       |       |   `--IDENT -> Integer [9:35]
        |   |       |       `--GENERIC_END -> > [9:42]
        |   |       `--IDENT -> test [9:44]
        |   |--RPAREN -> ) [9:48]
        |   `--SLIST -> { [9:50]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [10:9]
        |       |   |--MODIFIERS -> MODIFIERS [10:9]
        |       |   |--TYPE -> TYPE [10:9]
        |       |   |   |--IDENT -> Box [10:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [10:12]
        |       |   |       |--GENERIC_START -> < [10:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [10:13]
        |       |   |       |   `--IDENT -> String [10:13]
        |       |   |       `--GENERIC_END -> > [10:19]
        |       |   |--IDENT -> b [10:21]
        |       |   `--ASSIGN -> = [10:23]
        |       |       `--EXPR -> EXPR [10:25]
        |       |           `--LITERAL_NEW -> new [10:25]
        |       |               |--IDENT -> Box [10:29]
        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [10:32]
        |       |               |   |--GENERIC_START -> < [10:32]
        |       |               |   `--GENERIC_END -> > [10:33]
        |       |               |--LPAREN -> ( [10:34]
        |       |               |--ELIST -> ELIST [10:35]
        |       |               |   `--EXPR -> EXPR [10:35]
        |       |               |       `--LITERAL_NULL -> null [10:35]
        |       |               `--RPAREN -> ) [10:39]
        |       |--SEMI -> ; [10:40]
        |       `--RCURLY -> } [11:5]
        |--METHOD_DEF -> METHOD_DEF [13:5]
        |   |--MODIFIERS -> MODIFIERS [13:5]
        |   |--TYPE -> TYPE [13:5]
        |   |   `--LITERAL_INT -> int [13:5]
        |   |--IDENT -> m2 [13:9]
        |   |--LPAREN -> ( [13:11]
        |   |--PARAMETERS -> PARAMETERS [13:12]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [13:12]
        |   |       |--MODIFIERS -> MODIFIERS [13:12]
        |   |       |--TYPE -> TYPE [13:12]
        |   |       |   |--IDENT -> Box [13:12]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:15]
        |   |       |       |--GENERIC_START -> < [13:15]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:16]
        |   |       |       |   `--IDENT -> String [13:16]
        |   |       |       `--GENERIC_END -> > [13:22]
        |   |       `--IDENT -> b [13:24]
        |   |--RPAREN -> ) [13:25]
        |   `--SLIST -> { [13:27]
        |       |--LITERAL_IF -> if [14:9]
        |       |   |--LPAREN -> ( [14:12]
        |       |   |--EXPR -> EXPR [14:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [14:15]
        |       |   |       |--IDENT -> b [14:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [14:26]
        |       |   |           |--TYPE -> TYPE [14:26]
        |       |   |           |   |--IDENT -> Box [14:26]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:29]
        |       |   |           |       |--GENERIC_START -> < [14:29]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:30]
        |       |   |           |       |   `--IDENT -> String [14:30]
        |       |   |           |       `--GENERIC_END -> > [14:36]
        |       |   |           |--LPAREN -> ( [14:37]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:38]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:38]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [14:38]
        |       |   |           |       |--TYPE -> TYPE [14:38]
        |       |   |           |       |   `--IDENT -> String [14:38]
        |       |   |           |       `--IDENT -> s [14:45]
        |       |   |           `--RPAREN -> ) [14:46]
        |       |   |--RPAREN -> ) [14:47]
        |       |   `--LITERAL_RETURN -> return [14:49]
        |       |       |--EXPR -> EXPR [14:56]
        |       |       |   `--NUM_INT -> 1 [14:56]
        |       |       `--SEMI -> ; [14:57]
        |       |--LITERAL_IF -> if [15:9]
        |       |   |--LPAREN -> ( [15:12]
        |       |   |--EXPR -> EXPR [18:13]
        |       |   |   `--LAND -> && [18:13]
        |       |   |       |--LAND -> && [17:13]
        |       |   |       |   |--LAND -> && [16:13]
        |       |   |       |   |   |--LITERAL_INSTANCEOF -> instanceof [15:15]
        |       |   |       |   |   |   |--IDENT -> b [15:13]
        |       |   |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [15:26]
        |       |   |       |   |   |       |--MODIFIERS -> MODIFIERS [15:26]
        |       |   |       |   |   |       |--TYPE -> TYPE [15:26]
        |       |   |       |   |   |       |   |--IDENT -> Box [15:26]
        |       |   |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:29]
        |       |   |       |   |   |       |       |--GENERIC_START -> < [15:29]
        |       |   |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:30]
        |       |   |       |   |   |       |       |   `--IDENT -> String [15:30]
        |       |   |       |   |   |       |       `--GENERIC_END -> > [15:36]
        |       |   |       |   |   |       |--LPAREN -> ( [15:37]
        |       |   |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [15:38]
        |       |   |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:38]
        |       |   |       |   |   |       |       |--MODIFIERS -> MODIFIERS [15:38]
        |       |   |       |   |   |       |       |--TYPE -> TYPE [15:38]
        |       |   |       |   |   |       |       |   `--IDENT -> String [15:38]
        |       |   |       |   |   |       |       `--IDENT -> s [15:45]
        |       |   |       |   |   |       `--RPAREN -> ) [15:46]
        |       |   |       |   |   `--NOT_EQUAL -> != [16:20]
        |       |   |       |   |       |--DOT -> . [16:17]
        |       |   |       |   |       |   |--IDENT -> b [16:16]
        |       |   |       |   |       |   `--IDENT -> v [16:18]
        |       |   |       |   |       `--LITERAL_NULL -> null [16:23]
        |       |   |       |   `--NOT_EQUAL -> != [17:22]
        |       |   |       |       |--METHOD_CALL -> ( [17:19]
        |       |   |       |       |   |--DOT -> . [17:17]
        |       |   |       |       |   |   |--IDENT -> b [17:16]
        |       |   |       |       |   |   `--IDENT -> v [17:18]
        |       |   |       |       |   |--ELIST -> ELIST [17:20]
        |       |   |       |       |   `--RPAREN -> ) [17:20]
        |       |   |       |       `--LITERAL_NULL -> null [17:25]
        |       |   |       `--METHOD_CALL -> ( [18:33]
        |       |   |           |--DOT -> . [18:26]
        |       |   |           |   |--STRING_LITERAL -> "whatever" [18:16]
        |       |   |           |   `--IDENT -> equals [18:27]
        |       |   |           |--ELIST -> ELIST [18:35]
        |       |   |           |   `--EXPR -> EXPR [18:35]
        |       |   |           |       `--DOT -> . [18:35]
        |       |   |           |           |--IDENT -> b [18:34]
        |       |   |           |           `--IDENT -> v [18:36]
        |       |   |           `--RPAREN -> ) [18:37]
        |       |   |--RPAREN -> ) [18:38]
        |       |   `--LITERAL_RETURN -> return [18:40]
        |       |       |--EXPR -> EXPR [18:47]
        |       |       |   `--NUM_INT -> 1 [18:47]
        |       |       `--SEMI -> ; [18:48]
        |       |--LITERAL_RETURN -> return [19:9]
        |       |   |--EXPR -> EXPR [19:16]
        |       |   |   `--UNARY_MINUS -> - [19:16]
        |       |   |       `--NUM_INT -> 1 [19:17]
        |       |   `--SEMI -> ; [19:18]
        |       `--RCURLY -> } [20:5]
        |--METHOD_DEF -> METHOD_DEF [22:5]
        |   |--MODIFIERS -> MODIFIERS [22:5]
        |   |--TYPE -> TYPE [22:5]
        |   |   `--LITERAL_INT -> int [22:5]
        |   |--IDENT -> m3 [22:9]
        |   |--LPAREN -> ( [22:11]
        |   |--PARAMETERS -> PARAMETERS [22:12]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [22:12]
        |   |       |--MODIFIERS -> MODIFIERS [22:12]
        |   |       |--TYPE -> TYPE [22:12]
        |   |       |   |--IDENT -> Box [22:12]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [22:15]
        |   |       |       |--GENERIC_START -> < [22:15]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [22:16]
        |   |       |       |   `--IDENT -> String [22:16]
        |   |       |       `--GENERIC_END -> > [22:22]
        |   |       `--IDENT -> b [22:24]
        |   |--RPAREN -> ) [22:25]
        |   `--SLIST -> { [22:27]
        |       |--LITERAL_SWITCH -> switch [23:9]
        |       |   |--LPAREN -> ( [23:16]
        |       |   |--EXPR -> EXPR [23:17]
        |       |   |   `--IDENT -> b [23:17]
        |       |   |--RPAREN -> ) [23:18]
        |       |   |--LCURLY -> { [23:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [24:13]
        |       |   |   |--LITERAL_CASE -> case [24:13]
        |       |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [24:18]
        |       |   |   |   |   |--TYPE -> TYPE [24:18]
        |       |   |   |   |   |   |--IDENT -> Box [24:18]
        |       |   |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:21]
        |       |   |   |   |   |       |--GENERIC_START -> < [24:21]
        |       |   |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:22]
        |       |   |   |   |   |       |   `--IDENT -> String [24:22]
        |       |   |   |   |   |       `--GENERIC_END -> > [24:28]
        |       |   |   |   |   |--LPAREN -> ( [24:29]
        |       |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:30]
        |       |   |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:30]
        |       |   |   |   |   |       |--MODIFIERS -> MODIFIERS [24:30]
        |       |   |   |   |   |       |--TYPE -> TYPE [24:30]
        |       |   |   |   |   |       |   `--IDENT -> String [24:30]
        |       |   |   |   |   |       `--IDENT -> s [24:37]
        |       |   |   |   |   `--RPAREN -> ) [24:38]
        |       |   |   |   `--COLON -> : [24:39]
        |       |   |   `--SLIST -> SLIST [24:41]
        |       |   |       `--LITERAL_RETURN -> return [24:41]
        |       |   |           |--EXPR -> EXPR [24:48]
        |       |   |           |   `--NUM_INT -> 1 [24:48]
        |       |   |           `--SEMI -> ; [24:49]
        |       |   |--CASE_GROUP -> CASE_GROUP [25:13]
        |       |   |   |--LITERAL_DEFAULT -> default [25:13]
        |       |   |   |   `--COLON -> : [25:20]
        |       |   |   `--SLIST -> SLIST [25:22]
        |       |   |       `--LITERAL_RETURN -> return [25:22]
        |       |   |           |--EXPR -> EXPR [25:29]
        |       |   |           |   `--UNARY_MINUS -> - [25:29]
        |       |   |           |       `--NUM_INT -> 1 [25:30]
        |       |   |           `--SEMI -> ; [25:31]
        |       |   `--RCURLY -> } [26:9]
        |       `--RCURLY -> } [27:5]
        |--METHOD_DEF -> METHOD_DEF [29:5]
        |   |--MODIFIERS -> MODIFIERS [29:5]
        |   |--TYPE -> TYPE [29:5]
        |   |   `--LITERAL_INT -> int [29:5]
        |   |--IDENT -> m4 [29:9]
        |   |--LPAREN -> ( [29:11]
        |   |--PARAMETERS -> PARAMETERS [29:12]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [29:12]
        |   |       |--MODIFIERS -> MODIFIERS [29:12]
        |   |       |--TYPE -> TYPE [29:12]
        |   |       |   |--IDENT -> Box [29:12]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:15]
        |   |       |       |--GENERIC_START -> < [29:15]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:16]
        |   |       |       |   `--IDENT -> String [29:16]
        |   |       |       `--GENERIC_END -> > [29:22]
        |   |       `--IDENT -> b [29:24]
        |   |--RPAREN -> ) [29:25]
        |   `--SLIST -> { [29:27]
        |       |--LITERAL_RETURN -> return [30:9]
        |       |   |--EXPR -> EXPR [30:16]
        |       |   |   `--LITERAL_SWITCH -> switch [30:16]
        |       |   |       |--LPAREN -> ( [30:23]
        |       |   |       |--EXPR -> EXPR [30:24]
        |       |   |       |   `--IDENT -> b [30:24]
        |       |   |       |--RPAREN -> ) [30:25]
        |       |   |       |--LCURLY -> { [30:27]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [31:13]
        |       |   |       |   |--LITERAL_CASE -> case [31:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [31:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [31:18]
        |       |   |       |   |       |--TYPE -> TYPE [31:18]
        |       |   |       |   |       |   |--IDENT -> Box [31:18]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:21]
        |       |   |       |   |       |       |--GENERIC_START -> < [31:21]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:22]
        |       |   |       |   |       |       |   `--IDENT -> String [31:22]
        |       |   |       |   |       |       `--GENERIC_END -> > [31:28]
        |       |   |       |   |       |--LPAREN -> ( [31:29]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [31:30]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:30]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [31:30]
        |       |   |       |   |       |       |--TYPE -> TYPE [31:30]
        |       |   |       |   |       |       |   `--IDENT -> String [31:30]
        |       |   |       |   |       |       `--IDENT -> s [31:37]
        |       |   |       |   |       `--RPAREN -> ) [31:38]
        |       |   |       |   |--LAMBDA -> -> [31:40]
        |       |   |       |   |--EXPR -> EXPR [31:43]
        |       |   |       |   |   `--NUM_INT -> 1 [31:43]
        |       |   |       |   `--SEMI -> ; [31:44]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [32:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [32:13]
        |       |   |       |   |--LAMBDA -> -> [32:21]
        |       |   |       |   |--EXPR -> EXPR [32:24]
        |       |   |       |   |   `--UNARY_MINUS -> - [32:24]
        |       |   |       |   |       `--NUM_INT -> 1 [32:25]
        |       |   |       |   `--SEMI -> ; [32:26]
        |       |   |       `--RCURLY -> } [33:9]
        |       |   `--SEMI -> ; [33:10]
        |       `--RCURLY -> } [34:5]
        |--METHOD_DEF -> METHOD_DEF [36:5]
        |   |--MODIFIERS -> MODIFIERS [36:5]
        |   |--TYPE -> TYPE [36:5]
        |   |   `--LITERAL_INT -> int [36:5]
        |   |--IDENT -> m5 [36:9]
        |   |--LPAREN -> ( [36:11]
        |   |--PARAMETERS -> PARAMETERS [36:12]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:12]
        |   |       |--MODIFIERS -> MODIFIERS [36:12]
        |   |       |--TYPE -> TYPE [36:12]
        |   |       |   |--IDENT -> Box [36:12]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:15]
        |   |       |       |--GENERIC_START -> < [36:15]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:16]
        |   |       |       |   |--IDENT -> Box [36:16]
        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:19]
        |   |       |       |       |--GENERIC_START -> < [36:19]
        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:20]
        |   |       |       |       |   `--IDENT -> String [36:20]
        |   |       |       |       `--GENERIC_END -> > [36:26]
        |   |       |       `--GENERIC_END -> > [36:27]
        |   |       `--IDENT -> b [36:29]
        |   |--RPAREN -> ) [36:30]
        |   `--SLIST -> { [36:32]
        |       |--LITERAL_RETURN -> return [37:9]
        |       |   |--EXPR -> EXPR [37:16]
        |       |   |   `--LITERAL_SWITCH -> switch [37:16]
        |       |   |       |--LPAREN -> ( [37:23]
        |       |   |       |--EXPR -> EXPR [37:24]
        |       |   |       |   `--IDENT -> b [37:24]
        |       |   |       |--RPAREN -> ) [37:25]
        |       |   |       |--LCURLY -> { [37:27]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [38:13]
        |       |   |       |   |--LITERAL_CASE -> case [38:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [39:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [39:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [38:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [38:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [38:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [38:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [38:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [38:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [38:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [38:33]
        |       |   |       |   |           |   |--LPAREN -> ( [38:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:35]
        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [38:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [38:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [38:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [38:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:39]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [38:45]
        |       |   |       |   |           |   |       |--LPAREN -> ( [38:46]
        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:47]
        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:47]
        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [38:47]
        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [38:47]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:47]
        |       |   |       |   |           |   |       |       `--IDENT -> s [38:54]
        |       |   |       |   |           |   |       |--RPAREN -> ) [38:55]
        |       |   |       |   |           |   |       `--IDENT -> box [38:56]
        |       |   |       |   |           |   `--RPAREN -> ) [38:59]
        |       |   |       |   |           `--EXPR -> EXPR [39:43]
        |       |   |       |   |               `--LAND -> && [39:43]
        |       |   |       |   |                   |--METHOD_CALL -> ( [39:39]
        |       |   |       |   |                   |   |--DOT -> . [39:32]
        |       |   |       |   |                   |   |   |--STRING_LITERAL -> "test" [39:26]
        |       |   |       |   |                   |   |   `--IDENT -> equals [39:33]
        |       |   |       |   |                   |   |--ELIST -> ELIST [39:40]
        |       |   |       |   |                   |   |   `--EXPR -> EXPR [39:40]
        |       |   |       |   |                   |   |       `--IDENT -> s [39:40]
        |       |   |       |   |                   |   `--RPAREN -> ) [39:41]
        |       |   |       |   |                   `--NOT_EQUAL -> != [39:52]
        |       |   |       |   |                       |--DOT -> . [39:49]
        |       |   |       |   |                       |   |--IDENT -> box [39:46]
        |       |   |       |   |                       |   `--IDENT -> x [39:50]
        |       |   |       |   |                       `--NUM_INT -> 7 [39:55]
        |       |   |       |   |--LAMBDA -> -> [39:58]
        |       |   |       |   |--EXPR -> EXPR [39:61]
        |       |   |       |   |   `--NUM_INT -> 1 [39:61]
        |       |   |       |   `--SEMI -> ; [39:62]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [40:13]
        |       |   |       |   |--LITERAL_CASE -> case [40:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [41:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [41:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [40:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [40:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [40:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [40:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [40:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [40:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [40:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [40:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [40:33]
        |       |   |       |   |           |   |--LPAREN -> ( [40:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [40:35]
        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [40:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [40:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [40:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [40:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [40:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:39]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [40:45]
        |       |   |       |   |           |   |       |--LPAREN -> ( [40:46]
        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [40:47]
        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [40:47]
        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [40:47]
        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [40:47]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:47]
        |       |   |       |   |           |   |       |       `--IDENT -> s [40:54]
        |       |   |       |   |           |   |       |--RPAREN -> ) [40:55]
        |       |   |       |   |           |   |       `--IDENT -> box [40:56]
        |       |   |       |   |           |   `--RPAREN -> ) [40:59]
        |       |   |       |   |           `--EXPR -> EXPR [41:43]
        |       |   |       |   |               `--LAND -> && [41:43]
        |       |   |       |   |                   |--METHOD_CALL -> ( [41:39]
        |       |   |       |   |                   |   |--DOT -> . [41:32]
        |       |   |       |   |                   |   |   |--STRING_LITERAL -> "test" [41:26]
        |       |   |       |   |                   |   |   `--IDENT -> equals [41:33]
        |       |   |       |   |                   |   |--ELIST -> ELIST [41:40]
        |       |   |       |   |                   |   |   `--EXPR -> EXPR [41:40]
        |       |   |       |   |                   |   |       `--IDENT -> s [41:40]
        |       |   |       |   |                   |   `--RPAREN -> ) [41:41]
        |       |   |       |   |                   `--NOT_EQUAL -> != [41:58]
        |       |   |       |   |                       |--TYPECAST -> ( [41:46]
        |       |   |       |   |                       |   |--TYPE -> TYPE [41:47]
        |       |   |       |   |                       |   |   `--LITERAL_INT -> int [41:47]
        |       |   |       |   |                       |   |--RPAREN -> ) [41:50]
        |       |   |       |   |                       |   `--DOT -> . [41:55]
        |       |   |       |   |                       |       |--IDENT -> box [41:52]
        |       |   |       |   |                       |       `--IDENT -> x [41:56]
        |       |   |       |   |                       `--NUM_INT -> 7 [41:61]
        |       |   |       |   |--LAMBDA -> -> [41:64]
        |       |   |       |   |--EXPR -> EXPR [41:67]
        |       |   |       |   |   `--NUM_INT -> 1 [41:67]
        |       |   |       |   `--SEMI -> ; [41:68]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [42:13]
        |       |   |       |   |--LITERAL_CASE -> case [42:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [43:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [43:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [42:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [42:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [42:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [42:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [42:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [42:33]
        |       |   |       |   |           |   |--LPAREN -> ( [42:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:35]
        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [42:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [42:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [42:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:39]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:45]
        |       |   |       |   |           |   |       |--LPAREN -> ( [42:46]
        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:47]
        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [42:47]
        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [42:47]
        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [42:47]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:47]
        |       |   |       |   |           |   |       |       `--IDENT -> s [42:54]
        |       |   |       |   |           |   |       |--RPAREN -> ) [42:55]
        |       |   |       |   |           |   |       `--IDENT -> box [42:56]
        |       |   |       |   |           |   `--RPAREN -> ) [42:59]
        |       |   |       |   |           `--EXPR -> EXPR [43:43]
        |       |   |       |   |               `--LAND -> && [43:43]
        |       |   |       |   |                   |--METHOD_CALL -> ( [43:39]
        |       |   |       |   |                   |   |--DOT -> . [43:32]
        |       |   |       |   |                   |   |   |--STRING_LITERAL -> "test" [43:26]
        |       |   |       |   |                   |   |   `--IDENT -> equals [43:33]
        |       |   |       |   |                   |   |--ELIST -> ELIST [43:40]
        |       |   |       |   |                   |   |   `--EXPR -> EXPR [43:40]
        |       |   |       |   |                   |   |       `--IDENT -> s [43:40]
        |       |   |       |   |                   |   `--RPAREN -> ) [43:41]
        |       |   |       |   |                   `--METHOD_CALL -> ( [43:60]
        |       |   |       |   |                       |--DOT -> . [43:53]
        |       |   |       |   |                       |   |--IDENT -> Objects [43:46]
        |       |   |       |   |                       |   `--IDENT -> equals [43:54]
        |       |   |       |   |                       |--ELIST -> ELIST [43:64]
        |       |   |       |   |                       |   |--EXPR -> EXPR [43:64]
        |       |   |       |   |                       |   |   `--DOT -> . [43:64]
        |       |   |       |   |                       |   |       |--IDENT -> box [43:61]
        |       |   |       |   |                       |   |       `--IDENT -> v [43:65]
        |       |   |       |   |                       |   |--COMMA -> , [43:66]
        |       |   |       |   |                       |   `--EXPR -> EXPR [43:68]
        |       |   |       |   |                       |       `--STRING_LITERAL -> "box" [43:68]
        |       |   |       |   |                       `--RPAREN -> ) [43:73]
        |       |   |       |   |--LAMBDA -> -> [43:75]
        |       |   |       |   |--EXPR -> EXPR [43:78]
        |       |   |       |   |   `--NUM_INT -> 1 [43:78]
        |       |   |       |   `--SEMI -> ; [43:79]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [44:13]
        |       |   |       |   |--LITERAL_CASE -> case [44:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [45:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [45:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [44:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [44:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [44:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [44:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [44:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [44:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [44:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [44:33]
        |       |   |       |   |           |   |--LPAREN -> ( [44:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:35]
        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [44:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [44:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [44:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [44:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:39]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [44:45]
        |       |   |       |   |           |   |       |--LPAREN -> ( [44:46]
        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:47]
        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [44:47]
        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [44:47]
        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [44:47]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:47]
        |       |   |       |   |           |   |       |       `--IDENT -> s [44:54]
        |       |   |       |   |           |   |       |--RPAREN -> ) [44:55]
        |       |   |       |   |           |   |       `--IDENT -> box [44:56]
        |       |   |       |   |           |   `--RPAREN -> ) [44:59]
        |       |   |       |   |           `--EXPR -> EXPR [46:25]
        |       |   |       |   |               `--LOR -> || [46:25]
        |       |   |       |   |                   |--LAND -> && [45:43]
        |       |   |       |   |                   |   |--METHOD_CALL -> ( [45:39]
        |       |   |       |   |                   |   |   |--DOT -> . [45:32]
        |       |   |       |   |                   |   |   |   |--STRING_LITERAL -> "test" [45:26]
        |       |   |       |   |                   |   |   |   `--IDENT -> equals [45:33]
        |       |   |       |   |                   |   |   |--ELIST -> ELIST [45:40]
        |       |   |       |   |                   |   |   |   `--EXPR -> EXPR [45:40]
        |       |   |       |   |                   |   |   |       `--IDENT -> s [45:40]
        |       |   |       |   |                   |   |   `--RPAREN -> ) [45:41]
        |       |   |       |   |                   |   `--METHOD_CALL -> ( [45:60]
        |       |   |       |   |                   |       |--DOT -> . [45:53]
        |       |   |       |   |                   |       |   |--IDENT -> Objects [45:46]
        |       |   |       |   |                   |       |   `--IDENT -> equals [45:54]
        |       |   |       |   |                   |       |--ELIST -> ELIST [45:64]
        |       |   |       |   |                   |       |   |--EXPR -> EXPR [45:64]
        |       |   |       |   |                   |       |   |   `--DOT -> . [45:64]
        |       |   |       |   |                   |       |   |       |--IDENT -> box [45:61]
        |       |   |       |   |                   |       |   |       `--IDENT -> v [45:65]
        |       |   |       |   |                   |       |   |--COMMA -> , [45:66]
        |       |   |       |   |                   |       |   `--EXPR -> EXPR [45:68]
        |       |   |       |   |                   |       |       `--STRING_LITERAL -> "box" [45:68]
        |       |   |       |   |                   |       `--RPAREN -> ) [45:73]
        |       |   |       |   |                   `--METHOD_CALL -> ( [46:51]
        |       |   |       |   |                       |--DOT -> . [46:44]
        |       |   |       |   |                       |   |--STRING_LITERAL -> "something else" [46:28]
        |       |   |       |   |                       |   `--IDENT -> equals [46:45]
        |       |   |       |   |                       |--ELIST -> ELIST [46:52]
        |       |   |       |   |                       |   `--EXPR -> EXPR [46:52]
        |       |   |       |   |                       |       `--IDENT -> s [46:52]
        |       |   |       |   |                       `--RPAREN -> ) [46:53]
        |       |   |       |   |--LAMBDA -> -> [46:55]
        |       |   |       |   |--EXPR -> EXPR [46:58]
        |       |   |       |   |   `--NUM_INT -> 1 [46:58]
        |       |   |       |   `--SEMI -> ; [46:59]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [47:13]
        |       |   |       |   |--LITERAL_CASE -> case [47:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [48:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [48:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [47:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [47:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [47:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [47:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [47:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [47:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [47:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [47:33]
        |       |   |       |   |           |   |--LPAREN -> ( [47:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:35]
        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [47:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [47:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [47:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [47:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:39]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [47:45]
        |       |   |       |   |           |   |       |--LPAREN -> ( [47:46]
        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:47]
        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:47]
        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [47:47]
        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [47:47]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:47]
        |       |   |       |   |           |   |       |       `--IDENT -> s [47:54]
        |       |   |       |   |           |   |       `--RPAREN -> ) [47:55]
        |       |   |       |   |           |   `--RPAREN -> ) [47:56]
        |       |   |       |   |           `--EXPR -> EXPR [48:39]
        |       |   |       |   |               `--METHOD_CALL -> ( [48:39]
        |       |   |       |   |                   |--DOT -> . [48:32]
        |       |   |       |   |                   |   |--STRING_LITERAL -> "test" [48:26]
        |       |   |       |   |                   |   `--IDENT -> equals [48:33]
        |       |   |       |   |                   |--ELIST -> ELIST [48:40]
        |       |   |       |   |                   |   `--EXPR -> EXPR [48:40]
        |       |   |       |   |                   |       `--IDENT -> s [48:40]
        |       |   |       |   |                   `--RPAREN -> ) [48:41]
        |       |   |       |   |--LAMBDA -> -> [48:43]
        |       |   |       |   |--EXPR -> EXPR [48:46]
        |       |   |       |   |   `--NUM_INT -> 1 [48:46]
        |       |   |       |   `--SEMI -> ; [48:47]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [49:13]
        |       |   |       |   |--LITERAL_CASE -> case [49:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [50:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [50:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [49:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [49:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [49:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [49:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [49:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [49:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [49:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [49:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [49:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [49:33]
        |       |   |       |   |           |   |--LPAREN -> ( [49:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [49:35]
        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [49:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [49:35]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [49:35]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:38]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [49:38]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:39]
        |       |   |       |   |           |   |       |       |   `--WILDCARD_TYPE -> ? [49:39]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [49:40]
        |       |   |       |   |           |   |       `--IDENT -> b2 [49:42]
        |       |   |       |   |           |   `--RPAREN -> ) [49:44]
        |       |   |       |   |           `--EXPR -> EXPR [50:39]
        |       |   |       |   |               `--METHOD_CALL -> ( [50:39]
        |       |   |       |   |                   |--DOT -> . [50:32]
        |       |   |       |   |                   |   |--STRING_LITERAL -> "test" [50:26]
        |       |   |       |   |                   |   `--IDENT -> equals [50:33]
        |       |   |       |   |                   |--ELIST -> ELIST [50:42]
        |       |   |       |   |                   |   `--EXPR -> EXPR [50:42]
        |       |   |       |   |                   |       `--DOT -> . [50:42]
        |       |   |       |   |                   |           |--IDENT -> b2 [50:40]
        |       |   |       |   |                   |           `--IDENT -> v [50:43]
        |       |   |       |   |                   `--RPAREN -> ) [50:44]
        |       |   |       |   |--LAMBDA -> -> [50:46]
        |       |   |       |   |--EXPR -> EXPR [50:49]
        |       |   |       |   |   `--NUM_INT -> 1 [50:49]
        |       |   |       |   `--SEMI -> ; [50:50]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [51:13]
        |       |   |       |   |--LITERAL_CASE -> case [51:13]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [52:21]
        |       |   |       |   |       `--LITERAL_WHEN -> when [52:21]
        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [51:18]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [51:18]
        |       |   |       |   |           |   |--TYPE -> TYPE [51:18]
        |       |   |       |   |           |   |   |--IDENT -> Box [51:18]
        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:21]
        |       |   |       |   |           |   |       |--GENERIC_START -> < [51:21]
        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:22]
        |       |   |       |   |           |   |       |   |--IDENT -> Box [51:22]
        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:25]
        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [51:25]
        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:26]
        |       |   |       |   |           |   |       |       |   `--IDENT -> String [51:26]
        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [51:32]
        |       |   |       |   |           |   |       `--GENERIC_END -> > [51:33]
        |       |   |       |   |           |   |--LPAREN -> ( [51:34]
        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [51:35]
        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:35]
        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [51:35]
        |       |   |       |   |           |   |       |--TYPE -> TYPE [51:35]
        |       |   |       |   |           |   |       |   `--IDENT -> Object [51:35]
        |       |   |       |   |           |   |       `--IDENT -> o [51:42]
        |       |   |       |   |           |   |--RPAREN -> ) [51:43]
        |       |   |       |   |           |   `--IDENT -> b2 [51:45]
        |       |   |       |   |           `--EXPR -> EXPR [52:39]
        |       |   |       |   |               `--LAND -> && [52:39]
        |       |   |       |   |                   |--NOT_EQUAL -> != [52:31]
        |       |   |       |   |                   |   |--DOT -> . [52:28]
        |       |   |       |   |                   |   |   |--IDENT -> b2 [52:26]
        |       |   |       |   |                   |   |   `--IDENT -> v [52:29]
        |       |   |       |   |                   |   `--LITERAL_NULL -> null [52:34]
        |       |   |       |   |                   `--METHOD_CALL -> ( [52:59]
        |       |   |       |   |                       |--DOT -> . [52:52]
        |       |   |       |   |                       |   |--STRING_LITERAL -> "whatever" [52:42]
        |       |   |       |   |                       |   `--IDENT -> equals [52:53]
        |       |   |       |   |                       |--ELIST -> ELIST [52:70]
        |       |   |       |   |                       |   `--EXPR -> EXPR [52:70]
        |       |   |       |   |                       |       `--METHOD_CALL -> ( [52:70]
        |       |   |       |   |                       |           |--DOT -> . [52:61]
        |       |   |       |   |                       |           |   |--IDENT -> o [52:60]
        |       |   |       |   |                       |           |   `--IDENT -> toString [52:62]
        |       |   |       |   |                       |           |--ELIST -> ELIST [52:71]
        |       |   |       |   |                       |           `--RPAREN -> ) [52:71]
        |       |   |       |   |                       `--RPAREN -> ) [52:72]
        |       |   |       |   |--LAMBDA -> -> [52:73]
        |       |   |       |   |--EXPR -> EXPR [52:76]
        |       |   |       |   |   `--NUM_INT -> 1 [52:76]
        |       |   |       |   `--SEMI -> ; [52:77]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [53:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [53:13]
        |       |   |       |   |--LAMBDA -> -> [53:21]
        |       |   |       |   |--EXPR -> EXPR [53:24]
        |       |   |       |   |   `--UNARY_MINUS -> - [53:24]
        |       |   |       |   |       `--NUM_INT -> 1 [53:25]
        |       |   |       |   `--SEMI -> ; [53:26]
        |       |   |       `--RCURLY -> } [54:9]
        |       |   `--SEMI -> ; [54:10]
        |       `--RCURLY -> } [55:5]
        |--RECORD_DEF -> RECORD_DEF [57:5]
        |   |--MODIFIERS -> MODIFIERS [57:5]
        |   |--LITERAL_RECORD -> record [57:5]
        |   |--IDENT -> Box [57:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [57:15]
        |   |   |--GENERIC_START -> < [57:15]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [57:16]
        |   |   |   `--IDENT -> V [57:16]
        |   |   `--GENERIC_END -> > [57:17]
        |   |--LPAREN -> ( [57:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [57:19]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [57:19]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [57:19]
        |   |       |--TYPE -> TYPE [57:19]
        |   |       |   `--IDENT -> V [57:19]
        |   |       `--IDENT -> v [57:21]
        |   |--RPAREN -> ) [57:22]
        |   `--OBJBLOCK -> OBJBLOCK [57:24]
        |       |--LCURLY -> { [57:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [58:9]
        |       |   |--MODIFIERS -> MODIFIERS [58:9]
        |       |   |   `--LITERAL_STATIC -> static [58:9]
        |       |   |--TYPE -> TYPE [58:16]
        |       |   |   `--LITERAL_INT -> int [58:16]
        |       |   |--IDENT -> x [58:20]
        |       |   |--ASSIGN -> = [58:22]
        |       |   |   `--EXPR -> EXPR [58:24]
        |       |   |       `--NUM_INT -> 5 [58:24]
        |       |   `--SEMI -> ; [58:25]
        |       `--RCURLY -> } [59:5]
        `--RCURLY -> } [61:1]
