COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
|--PACKAGE_DEF -> package [2:0]
|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
|   |--DOT -> . [2:47]
|   |   |--DOT -> . [2:39]
|   |   |   |--DOT -> . [2:28]
|   |   |   |   |--DOT -> . [2:22]
|   |   |   |   |   |--DOT -> . [2:11]
|   |   |   |   |   |   |--IDENT -> com [2:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:12]
|   |   |   |   |   `--IDENT -> tools [2:23]
|   |   |   |   `--IDENT -> checkstyle [2:29]
|   |   |   `--IDENT -> grammar [2:40]
|   |   `--IDENT -> java21 [2:48]
|   `--SEMI -> ; [2:54]
`--CLASS_DEF -> CLASS_DEF [4:0]
    |--MODIFIERS -> MODIFIERS [4:0]
    |   `--LITERAL_PUBLIC -> public [4:0]
    |--LITERAL_CLASS -> class [4:7]
    |--IDENT -> InputUnnamedVariableSwitch [4:13]
    `--OBJBLOCK -> OBJBLOCK [4:40]
        |--LCURLY -> { [4:40]
        |--METHOD_DEF -> METHOD_DEF [5:8]
        |   |--MODIFIERS -> MODIFIERS [5:8]
        |   |--TYPE -> TYPE [5:8]
        |   |   `--LITERAL_INT -> int [5:8]
        |   |--IDENT -> testMultiValuesTopLevel [5:12]
        |   |--LPAREN -> ( [5:35]
        |   |--PARAMETERS -> PARAMETERS [5:36]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [5:36]
        |   |       |--MODIFIERS -> MODIFIERS [5:36]
        |   |       |--TYPE -> TYPE [5:36]
        |   |       |   `--IDENT -> Object [5:36]
        |   |       `--IDENT -> o [5:43]
        |   |--RPAREN -> ) [5:44]
        |   `--SLIST -> { [5:46]
        |       |--LITERAL_RETURN -> return [6:8]
        |       |   |--EXPR -> EXPR [6:15]
        |       |   |   `--LITERAL_SWITCH -> switch [6:15]
        |       |   |       |--LPAREN -> ( [6:22]
        |       |   |       |--EXPR -> EXPR [6:23]
        |       |   |       |   `--IDENT -> o [6:23]
        |       |   |       |--RPAREN -> ) [6:24]
        |       |   |       |--LCURLY -> { [6:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [7:12]
        |       |   |       |   |--LITERAL_CASE -> case [7:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [7:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [7:17]
        |       |   |       |   |   |   |   `--IDENT -> R1 [7:17]
        |       |   |       |   |   |   `--IDENT -> _ [7:20]
        |       |   |       |   |   |--COMMA -> , [7:21]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:23]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [7:23]
        |       |   |       |   |       |--TYPE -> TYPE [7:23]
        |       |   |       |   |       |   `--IDENT -> R2 [7:23]
        |       |   |       |   |       `--IDENT -> _ [7:26]
        |       |   |       |   |--LAMBDA -> -> [7:28]
        |       |   |       |   |--EXPR -> EXPR [7:31]
        |       |   |       |   |   `--NUM_INT -> 1 [7:31]
        |       |   |       |   `--SEMI -> ; [7:32]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [8:12]
        |       |   |       |   |--LITERAL_DEFAULT -> default [8:12]
        |       |   |       |   |--LAMBDA -> -> [8:20]
        |       |   |       |   |--EXPR -> EXPR [8:23]
        |       |   |       |   |   `--NUM_INT -> 2 [8:23]
        |       |   |       |   `--SEMI -> ; [8:24]
        |       |   |       `--RCURLY -> } [9:8]
        |       |   `--SEMI -> ; [9:9]
        |       `--RCURLY -> } [10:4]
        |--METHOD_DEF -> METHOD_DEF [12:4]
        |   |--MODIFIERS -> MODIFIERS [12:4]
        |   |--TYPE -> TYPE [12:4]
        |   |   `--LITERAL_INT -> int [12:4]
        |   |--IDENT -> testMultiValuesTopLevel2 [12:8]
        |   |--LPAREN -> ( [12:32]
        |   |--PARAMETERS -> PARAMETERS [12:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:33]
        |   |       |--MODIFIERS -> MODIFIERS [12:33]
        |   |       |--TYPE -> TYPE [12:33]
        |   |       |   `--IDENT -> Base [12:33]
        |   |       `--IDENT -> o [12:38]
        |   |--RPAREN -> ) [12:39]
        |   `--SLIST -> { [12:41]
        |       |--LITERAL_RETURN -> return [13:8]
        |       |   |--EXPR -> EXPR [13:15]
        |       |   |   `--LITERAL_SWITCH -> switch [13:15]
        |       |   |       |--LPAREN -> ( [13:22]
        |       |   |       |--EXPR -> EXPR [13:23]
        |       |   |       |   `--IDENT -> o [13:23]
        |       |   |       |--RPAREN -> ) [13:24]
        |       |   |       |--LCURLY -> { [13:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [14:12]
        |       |   |       |   |--LITERAL_CASE -> case [14:12]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [14:17]
        |       |   |       |   |       |--TYPE -> TYPE [14:17]
        |       |   |       |   |       |   `--IDENT -> R1 [14:17]
        |       |   |       |   |       `--IDENT -> r [14:20]
        |       |   |       |   |--LAMBDA -> -> [14:22]
        |       |   |       |   |--EXPR -> EXPR [14:25]
        |       |   |       |   |   `--NUM_INT -> 1 [14:25]
        |       |   |       |   `--SEMI -> ; [14:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [15:12]
        |       |   |       |   |--LITERAL_CASE -> case [15:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [15:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [15:17]
        |       |   |       |   |   |   |   `--IDENT -> R2 [15:17]
        |       |   |       |   |   |   `--IDENT -> _ [15:20]
        |       |   |       |   |   |--COMMA -> , [15:21]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:23]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [15:23]
        |       |   |       |   |   |   |--TYPE -> TYPE [15:23]
        |       |   |       |   |   |   |   `--IDENT -> R3 [15:23]
        |       |   |       |   |   |   `--IDENT -> _ [15:26]
        |       |   |       |   |   |--COMMA -> , [15:27]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [15:29]
        |       |   |       |   |       |--TYPE -> TYPE [15:29]
        |       |   |       |   |       |   `--IDENT -> R4 [15:29]
        |       |   |       |   |       `--IDENT -> _ [15:32]
        |       |   |       |   |--LAMBDA -> -> [15:34]
        |       |   |       |   |--EXPR -> EXPR [15:37]
        |       |   |       |   |   `--NUM_INT -> 2 [15:37]
        |       |   |       |   `--SEMI -> ; [15:38]
        |       |   |       `--RCURLY -> } [16:8]
        |       |   `--SEMI -> ; [16:9]
        |       `--RCURLY -> } [17:4]
        |--METHOD_DEF -> METHOD_DEF [19:4]
        |   |--MODIFIERS -> MODIFIERS [19:4]
        |   |--TYPE -> TYPE [19:4]
        |   |   `--LITERAL_INT -> int [19:4]
        |   |--IDENT -> testMultiValuesNested [19:8]
        |   |--LPAREN -> ( [19:29]
        |   |--PARAMETERS -> PARAMETERS [19:30]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [19:30]
        |   |       |--MODIFIERS -> MODIFIERS [19:30]
        |   |       |--TYPE -> TYPE [19:30]
        |   |       |   |--IDENT -> Box [19:30]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:33]
        |   |       |       |--GENERIC_START -> < [19:33]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:34]
        |   |       |       |   `--WILDCARD_TYPE -> ? [19:34]
        |   |       |       `--GENERIC_END -> > [19:35]
        |   |       `--IDENT -> b [19:37]
        |   |--RPAREN -> ) [19:38]
        |   `--SLIST -> { [19:40]
        |       |--LITERAL_RETURN -> return [20:8]
        |       |   |--EXPR -> EXPR [20:15]
        |       |   |   `--LITERAL_SWITCH -> switch [20:15]
        |       |   |       |--LPAREN -> ( [20:22]
        |       |   |       |--EXPR -> EXPR [20:23]
        |       |   |       |   `--IDENT -> b [20:23]
        |       |   |       |--RPAREN -> ) [20:24]
        |       |   |       |--LCURLY -> { [20:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [21:12]
        |       |   |       |   |--LITERAL_CASE -> case [21:12]
        |       |   |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [21:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [21:17]
        |       |   |       |   |   |   |   `--IDENT -> Box [21:17]
        |       |   |       |   |   |   |--LPAREN -> ( [21:20]
        |       |   |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:21]
        |       |   |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:21]
        |       |   |       |   |   |   |       |--MODIFIERS -> MODIFIERS [21:21]
        |       |   |       |   |   |   |       |--TYPE -> TYPE [21:21]
        |       |   |       |   |   |   |       |   `--IDENT -> R1 [21:21]
        |       |   |       |   |   |   |       `--IDENT -> _ [21:24]
        |       |   |       |   |   |   `--RPAREN -> ) [21:25]
        |       |   |       |   |   |--COMMA -> , [21:26]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:28]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [21:28]
        |       |   |       |   |       |--TYPE -> TYPE [21:28]
        |       |   |       |   |       |   `--IDENT -> Box [21:28]
        |       |   |       |   |       |--LPAREN -> ( [21:31]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:32]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:32]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [21:32]
        |       |   |       |   |       |       |--TYPE -> TYPE [21:32]
        |       |   |       |   |       |       |   `--IDENT -> R2 [21:32]
        |       |   |       |   |       |       `--IDENT -> _ [21:35]
        |       |   |       |   |       `--RPAREN -> ) [21:36]
        |       |   |       |   |--LAMBDA -> -> [21:38]
        |       |   |       |   |--EXPR -> EXPR [21:41]
        |       |   |       |   |   `--NUM_INT -> 1 [21:41]
        |       |   |       |   `--SEMI -> ; [21:42]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [22:12]
        |       |   |       |   |--LITERAL_CASE -> case [22:12]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [22:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [22:17]
        |       |   |       |   |       |--TYPE -> TYPE [22:17]
        |       |   |       |   |       |   `--IDENT -> Box [22:17]
        |       |   |       |   |       |--LPAREN -> ( [22:20]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [22:21]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:21]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [22:21]
        |       |   |       |   |       |       |--TYPE -> TYPE [22:21]
        |       |   |       |   |       |       |   `--IDENT -> R3 [22:21]
        |       |   |       |   |       |       `--IDENT -> _ [22:24]
        |       |   |       |   |       `--RPAREN -> ) [22:25]
        |       |   |       |   |--LAMBDA -> -> [22:27]
        |       |   |       |   |--EXPR -> EXPR [22:30]
        |       |   |       |   |   `--NUM_INT -> 2 [22:30]
        |       |   |       |   `--SEMI -> ; [22:31]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [23:12]
        |       |   |       |   |--LITERAL_CASE -> case [23:12]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [23:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [23:17]
        |       |   |       |   |       |--TYPE -> TYPE [23:17]
        |       |   |       |   |       |   `--IDENT -> Box [23:17]
        |       |   |       |   |       |--LPAREN -> ( [23:20]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [23:21]
        |       |   |       |   |       |   `--UNNAMED_PATTERN_DEF -> _ [23:21]
        |       |   |       |   |       `--RPAREN -> ) [23:22]
        |       |   |       |   |--LAMBDA -> -> [23:25]
        |       |   |       |   |--EXPR -> EXPR [23:28]
        |       |   |       |   |   `--NUM_INT -> 3 [23:28]
        |       |   |       |   `--SEMI -> ; [23:29]
        |       |   |       `--RCURLY -> } [24:8]
        |       |   `--SEMI -> ; [24:9]
        |       `--RCURLY -> } [25:4]
        |--METHOD_DEF -> METHOD_DEF [27:4]
        |   |--MODIFIERS -> MODIFIERS [27:4]
        |   |--TYPE -> TYPE [27:4]
        |   |   `--LITERAL_INT -> int [27:4]
        |   |--IDENT -> testMultiValuesNestedUnnamedVarAndPattern [27:8]
        |   |--LPAREN -> ( [27:49]
        |   |--PARAMETERS -> PARAMETERS [27:50]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [27:50]
        |   |       |--MODIFIERS -> MODIFIERS [27:50]
        |   |       |--TYPE -> TYPE [27:50]
        |   |       |   |--IDENT -> Box [27:50]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:53]
        |   |       |       |--GENERIC_START -> < [27:53]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:54]
        |   |       |       |   `--WILDCARD_TYPE -> ? [27:54]
        |   |       |       `--GENERIC_END -> > [27:55]
        |   |       `--IDENT -> b [27:57]
        |   |--RPAREN -> ) [27:58]
        |   `--SLIST -> { [27:60]
        |       |--LITERAL_RETURN -> return [28:8]
        |       |   |--EXPR -> EXPR [28:15]
        |       |   |   `--LITERAL_SWITCH -> switch [28:15]
        |       |   |       |--LPAREN -> ( [28:22]
        |       |   |       |--EXPR -> EXPR [28:23]
        |       |   |       |   `--IDENT -> b [28:23]
        |       |   |       |--RPAREN -> ) [28:24]
        |       |   |       |--LCURLY -> { [28:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [29:12]
        |       |   |       |   |--LITERAL_CASE -> case [29:12]
        |       |   |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [29:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [29:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [29:17]
        |       |   |       |   |   |   |   `--IDENT -> Box [29:17]
        |       |   |       |   |   |   |--LPAREN -> ( [29:20]
        |       |   |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [29:21]
        |       |   |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:21]
        |       |   |       |   |   |   |       |--MODIFIERS -> MODIFIERS [29:21]
        |       |   |       |   |   |   |       |--TYPE -> TYPE [29:21]
        |       |   |       |   |   |   |       |   `--IDENT -> R1 [29:21]
        |       |   |       |   |   |   |       `--IDENT -> _ [29:24]
        |       |   |       |   |   |   `--RPAREN -> ) [29:25]
        |       |   |       |   |   |--COMMA -> , [29:26]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [29:28]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [29:28]
        |       |   |       |   |       |--TYPE -> TYPE [29:28]
        |       |   |       |   |       |   `--IDENT -> Box [29:28]
        |       |   |       |   |       |--LPAREN -> ( [29:31]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [29:32]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:32]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [29:32]
        |       |   |       |   |       |       |--TYPE -> TYPE [29:32]
        |       |   |       |   |       |       |   `--IDENT -> R2 [29:32]
        |       |   |       |   |       |       `--IDENT -> _ [29:35]
        |       |   |       |   |       `--RPAREN -> ) [29:36]
        |       |   |       |   |--LAMBDA -> -> [29:38]
        |       |   |       |   |--EXPR -> EXPR [29:41]
        |       |   |       |   |   `--NUM_INT -> 1 [29:41]
        |       |   |       |   `--SEMI -> ; [29:42]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [30:12]
        |       |   |       |   |--LITERAL_CASE -> case [30:12]
        |       |   |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [30:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [30:17]
        |       |   |       |   |   |   |   `--IDENT -> Box [30:17]
        |       |   |       |   |   |   |--LPAREN -> ( [30:20]
        |       |   |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:21]
        |       |   |       |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [30:21]
        |       |   |       |   |   |   |       |--MODIFIERS -> MODIFIERS [30:21]
        |       |   |       |   |   |   |       |--TYPE -> TYPE [30:21]
        |       |   |       |   |   |   |       |   `--IDENT -> R3 [30:21]
        |       |   |       |   |   |   |       `--IDENT -> _ [30:24]
        |       |   |       |   |   |   `--RPAREN -> ) [30:25]
        |       |   |       |   |   |--COMMA -> , [30:26]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:28]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [30:28]
        |       |   |       |   |       |--TYPE -> TYPE [30:28]
        |       |   |       |   |       |   `--IDENT -> Box [30:28]
        |       |   |       |   |       |--LPAREN -> ( [30:31]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:32]
        |       |   |       |   |       |   `--UNNAMED_PATTERN_DEF -> _ [30:32]
        |       |   |       |   |       `--RPAREN -> ) [30:33]
        |       |   |       |   |--LAMBDA -> -> [30:35]
        |       |   |       |   |--EXPR -> EXPR [30:38]
        |       |   |       |   |   `--NUM_INT -> 2 [30:38]
        |       |   |       |   `--SEMI -> ; [30:39]
        |       |   |       `--RCURLY -> } [31:8]
        |       |   `--SEMI -> ; [31:9]
        |       `--RCURLY -> } [32:4]
        |--METHOD_DEF -> METHOD_DEF [34:4]
        |   |--MODIFIERS -> MODIFIERS [34:4]
        |   |--TYPE -> TYPE [34:4]
        |   |   `--LITERAL_INT -> int [34:4]
        |   |--IDENT -> testMultiValuesNestedMix [34:8]
        |   |--LPAREN -> ( [34:32]
        |   |--PARAMETERS -> PARAMETERS [34:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [34:33]
        |   |       |--MODIFIERS -> MODIFIERS [34:33]
        |   |       |--TYPE -> TYPE [34:33]
        |   |       |   `--IDENT -> Object [34:33]
        |   |       `--IDENT -> b [34:40]
        |   |--RPAREN -> ) [34:41]
        |   `--SLIST -> { [34:43]
        |       |--LITERAL_RETURN -> return [35:8]
        |       |   |--EXPR -> EXPR [35:15]
        |       |   |   `--LITERAL_SWITCH -> switch [35:15]
        |       |   |       |--LPAREN -> ( [35:22]
        |       |   |       |--EXPR -> EXPR [35:23]
        |       |   |       |   `--IDENT -> b [35:23]
        |       |   |       |--RPAREN -> ) [35:24]
        |       |   |       |--LCURLY -> { [35:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [36:12]
        |       |   |       |   |--LITERAL_CASE -> case [36:12]
        |       |   |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [36:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [36:17]
        |       |   |       |   |   |   |   `--IDENT -> Box [36:17]
        |       |   |       |   |   |   |--LPAREN -> ( [36:20]
        |       |   |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:21]
        |       |   |       |   |   |   |   `--UNNAMED_PATTERN_DEF -> _ [36:21]
        |       |   |       |   |   |   `--RPAREN -> ) [36:22]
        |       |   |       |   |   |--COMMA -> , [36:23]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:25]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [36:25]
        |       |   |       |   |       |--TYPE -> TYPE [36:25]
        |       |   |       |   |       |   `--IDENT -> Box2 [36:25]
        |       |   |       |   |       |--LPAREN -> ( [36:29]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:30]
        |       |   |       |   |       |   `--UNNAMED_PATTERN_DEF -> _ [36:30]
        |       |   |       |   |       `--RPAREN -> ) [36:31]
        |       |   |       |   |--LAMBDA -> -> [36:33]
        |       |   |       |   |--EXPR -> EXPR [36:36]
        |       |   |       |   |   `--NUM_INT -> 1 [36:36]
        |       |   |       |   `--SEMI -> ; [36:37]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [37:12]
        |       |   |       |   |--LITERAL_DEFAULT -> default [37:12]
        |       |   |       |   |--LAMBDA -> -> [37:20]
        |       |   |       |   |--EXPR -> EXPR [37:23]
        |       |   |       |   |   `--NUM_INT -> 2 [37:23]
        |       |   |       |   `--SEMI -> ; [37:24]
        |       |   |       `--RCURLY -> } [38:8]
        |       |   `--SEMI -> ; [38:9]
        |       `--RCURLY -> } [39:4]
        |--METHOD_DEF -> METHOD_DEF [41:4]
        |   |--MODIFIERS -> MODIFIERS [41:4]
        |   |--TYPE -> TYPE [41:4]
        |   |   `--LITERAL_INT -> int [41:4]
        |   |--IDENT -> testMultiValuesNestedMix2 [41:8]
        |   |--LPAREN -> ( [41:33]
        |   |--PARAMETERS -> PARAMETERS [41:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [41:34]
        |   |       |--MODIFIERS -> MODIFIERS [41:34]
        |   |       |--TYPE -> TYPE [41:34]
        |   |       |   `--IDENT -> Object [41:34]
        |   |       `--IDENT -> b [41:41]
        |   |--RPAREN -> ) [41:42]
        |   `--SLIST -> { [41:44]
        |       |--LITERAL_RETURN -> return [42:8]
        |       |   |--EXPR -> EXPR [42:15]
        |       |   |   `--LITERAL_SWITCH -> switch [42:15]
        |       |   |       |--LPAREN -> ( [42:22]
        |       |   |       |--EXPR -> EXPR [42:23]
        |       |   |       |   `--IDENT -> b [42:23]
        |       |   |       |--RPAREN -> ) [42:24]
        |       |   |       |--LCURLY -> { [42:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [43:12]
        |       |   |       |   |--LITERAL_CASE -> case [43:12]
        |       |   |       |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [43:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [43:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [43:17]
        |       |   |       |   |   |   |   `--IDENT -> Box [43:17]
        |       |   |       |   |   |   |--LPAREN -> ( [43:20]
        |       |   |       |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [43:21]
        |       |   |       |   |   |   |   `--UNNAMED_PATTERN_DEF -> _ [43:21]
        |       |   |       |   |   |   `--RPAREN -> ) [43:22]
        |       |   |       |   |   |--COMMA -> , [43:23]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:25]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [43:25]
        |       |   |       |   |       |--TYPE -> TYPE [43:25]
        |       |   |       |   |       |   `--IDENT -> String [43:25]
        |       |   |       |   |       `--IDENT -> _ [43:32]
        |       |   |       |   |--LAMBDA -> -> [43:34]
        |       |   |       |   |--EXPR -> EXPR [43:37]
        |       |   |       |   |   `--NUM_INT -> 1 [43:37]
        |       |   |       |   `--SEMI -> ; [43:38]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [44:12]
        |       |   |       |   |--LITERAL_DEFAULT -> default [44:12]
        |       |   |       |   |--LAMBDA -> -> [44:20]
        |       |   |       |   |--EXPR -> EXPR [44:23]
        |       |   |       |   |   `--NUM_INT -> 2 [44:23]
        |       |   |       |   `--SEMI -> ; [44:24]
        |       |   |       `--RCURLY -> } [45:8]
        |       |   `--SEMI -> ; [45:9]
        |       `--RCURLY -> } [46:4]
        |--METHOD_DEF -> METHOD_DEF [48:4]
        |   |--MODIFIERS -> MODIFIERS [48:4]
        |   |--TYPE -> TYPE [48:4]
        |   |   `--LITERAL_INT -> int [48:4]
        |   |--IDENT -> testMultiValuesStatementBlock2 [48:8]
        |   |--LPAREN -> ( [48:38]
        |   |--PARAMETERS -> PARAMETERS [48:39]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [48:39]
        |   |       |--MODIFIERS -> MODIFIERS [48:39]
        |   |       |--TYPE -> TYPE [48:39]
        |   |       |   `--IDENT -> Object [48:39]
        |   |       `--IDENT -> o [48:46]
        |   |--RPAREN -> ) [48:47]
        |   `--SLIST -> { [48:49]
        |       |--LITERAL_SWITCH -> switch [49:8]
        |       |   |--LPAREN -> ( [49:15]
        |       |   |--EXPR -> EXPR [49:16]
        |       |   |   `--IDENT -> o [49:16]
        |       |   |--RPAREN -> ) [49:17]
        |       |   |--LCURLY -> { [49:19]
        |       |   |--CASE_GROUP -> CASE_GROUP [50:12]
        |       |   |   |--LITERAL_CASE -> case [50:12]
        |       |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [50:17]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [50:17]
        |       |   |   |   |   |--TYPE -> TYPE [50:17]
        |       |   |   |   |   |   `--IDENT -> Box [50:17]
        |       |   |   |   |   |--LPAREN -> ( [50:20]
        |       |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [50:21]
        |       |   |   |   |   |   `--UNNAMED_PATTERN_DEF -> _ [50:21]
        |       |   |   |   |   `--RPAREN -> ) [50:22]
        |       |   |   |   `--COLON -> : [50:23]
        |       |   |   |--LITERAL_CASE -> case [51:12]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:17]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [51:17]
        |       |   |   |   |   |--TYPE -> TYPE [51:17]
        |       |   |   |   |   |   `--IDENT -> String [51:17]
        |       |   |   |   |   `--IDENT -> _ [51:24]
        |       |   |   |   `--COLON -> : [51:25]
        |       |   |   `--SLIST -> SLIST [52:16]
        |       |   |       `--LITERAL_RETURN -> return [52:16]
        |       |   |           |--EXPR -> EXPR [52:23]
        |       |   |           |   `--NUM_INT -> 1 [52:23]
        |       |   |           `--SEMI -> ; [52:24]
        |       |   |--CASE_GROUP -> CASE_GROUP [53:12]
        |       |   |   |--LITERAL_DEFAULT -> default [53:12]
        |       |   |   |   `--COLON -> : [53:19]
        |       |   |   `--SLIST -> SLIST [54:16]
        |       |   |       `--LITERAL_RETURN -> return [54:16]
        |       |   |           |--EXPR -> EXPR [54:23]
        |       |   |           |   `--NUM_INT -> 2 [54:23]
        |       |   |           `--SEMI -> ; [54:24]
        |       |   `--RCURLY -> } [55:8]
        |       `--RCURLY -> } [56:4]
        |--METHOD_DEF -> METHOD_DEF [58:4]
        |   |--MODIFIERS -> MODIFIERS [58:4]
        |   |--TYPE -> TYPE [58:4]
        |   |   `--LITERAL_INT -> int [58:4]
        |   |--IDENT -> testMultiValuesGuards [58:8]
        |   |--LPAREN -> ( [58:29]
        |   |--PARAMETERS -> PARAMETERS [58:30]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [58:30]
        |   |   |   |--MODIFIERS -> MODIFIERS [58:30]
        |   |   |   |--TYPE -> TYPE [58:30]
        |   |   |   |   `--IDENT -> Base [58:30]
        |   |   |   `--IDENT -> b [58:35]
        |   |   |--COMMA -> , [58:36]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:38]
        |   |       |--MODIFIERS -> MODIFIERS [58:38]
        |   |       |--TYPE -> TYPE [58:38]
        |   |       |   `--LITERAL_INT -> int [58:38]
        |   |       `--IDENT -> x [58:42]
        |   |--RPAREN -> ) [58:43]
        |   `--SLIST -> { [58:45]
        |       |--LITERAL_RETURN -> return [59:8]
        |       |   |--EXPR -> EXPR [59:15]
        |       |   |   `--LITERAL_SWITCH -> switch [59:15]
        |       |   |       |--LPAREN -> ( [59:22]
        |       |   |       |--EXPR -> EXPR [59:23]
        |       |   |       |   `--IDENT -> b [59:23]
        |       |   |       |--RPAREN -> ) [59:24]
        |       |   |       |--LCURLY -> { [59:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [60:12]
        |       |   |       |   |--LITERAL_CASE -> case [60:12]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [60:17]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [60:17]
        |       |   |       |   |       |--TYPE -> TYPE [60:17]
        |       |   |       |   |       |   `--IDENT -> R1 [60:17]
        |       |   |       |   |       `--IDENT -> r [60:20]
        |       |   |       |   |--LAMBDA -> -> [60:22]
        |       |   |       |   |--EXPR -> EXPR [60:25]
        |       |   |       |   |   `--NUM_INT -> 1 [60:25]
        |       |   |       |   `--SEMI -> ; [60:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [61:12]
        |       |   |       |   |--LITERAL_CASE -> case [61:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [61:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [61:17]
        |       |   |       |   |   |   |   `--IDENT -> R2 [61:17]
        |       |   |       |   |   |   `--IDENT -> _ [61:20]
        |       |   |       |   |   |--COMMA -> , [61:21]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:23]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [61:23]
        |       |   |       |   |   |   |--TYPE -> TYPE [61:23]
        |       |   |       |   |   |   |   `--IDENT -> R3 [61:23]
        |       |   |       |   |   |   `--IDENT -> _ [61:26]
        |       |   |       |   |   |--COMMA -> , [61:27]
        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [61:34]
        |       |   |       |   |       `--LITERAL_WHEN -> when [61:34]
        |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:29]
        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [61:29]
        |       |   |       |   |           |   |--TYPE -> TYPE [61:29]
        |       |   |       |   |           |   |   `--IDENT -> R4 [61:29]
        |       |   |       |   |           |   `--IDENT -> _ [61:32]
        |       |   |       |   |           `--EXPR -> EXPR [61:41]
        |       |   |       |   |               `--EQUAL -> == [61:41]
        |       |   |       |   |                   |--IDENT -> x [61:39]
        |       |   |       |   |                   `--NUM_INT -> 1 [61:44]
        |       |   |       |   |--LAMBDA -> -> [61:46]
        |       |   |       |   |--EXPR -> EXPR [61:49]
        |       |   |       |   |   `--NUM_INT -> 2 [61:49]
        |       |   |       |   `--SEMI -> ; [61:50]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [62:12]
        |       |   |       |   |--LITERAL_CASE -> case [62:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [62:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [62:17]
        |       |   |       |   |   |   |   `--IDENT -> R2 [62:17]
        |       |   |       |   |   |   `--IDENT -> _ [62:20]
        |       |   |       |   |   |--COMMA -> , [62:21]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:23]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [62:23]
        |       |   |       |   |   |   |--TYPE -> TYPE [62:23]
        |       |   |       |   |   |   |   `--IDENT -> R3 [62:23]
        |       |   |       |   |   |   `--IDENT -> _ [62:26]
        |       |   |       |   |   |--COMMA -> , [62:27]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [62:29]
        |       |   |       |   |       |--TYPE -> TYPE [62:29]
        |       |   |       |   |       |   `--IDENT -> R4 [62:29]
        |       |   |       |   |       `--IDENT -> _ [62:32]
        |       |   |       |   |--LAMBDA -> -> [62:34]
        |       |   |       |   |--EXPR -> EXPR [62:37]
        |       |   |       |   |   `--NUM_INT -> 3 [62:37]
        |       |   |       |   `--SEMI -> ; [62:38]
        |       |   |       `--RCURLY -> } [63:8]
        |       |   `--SEMI -> ; [63:9]
        |       `--RCURLY -> } [64:4]
        |--METHOD_DEF -> METHOD_DEF [66:4]
        |   |--MODIFIERS -> MODIFIERS [66:4]
        |   |--TYPE -> TYPE [66:4]
        |   |   `--LITERAL_INT -> int [66:4]
        |   |--IDENT -> testMixVarWithExplicit [66:8]
        |   |--LPAREN -> ( [66:30]
        |   |--PARAMETERS -> PARAMETERS [66:31]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:31]
        |   |       |--MODIFIERS -> MODIFIERS [66:31]
        |   |       |--TYPE -> TYPE [66:31]
        |   |       |   |--IDENT -> Box [66:31]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:34]
        |   |       |       |--GENERIC_START -> < [66:34]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:35]
        |   |       |       |   `--WILDCARD_TYPE -> ? [66:35]
        |   |       |       `--GENERIC_END -> > [66:36]
        |   |       `--IDENT -> t [66:38]
        |   |--RPAREN -> ) [66:39]
        |   `--SLIST -> { [66:41]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [67:8]
        |       |   |--MODIFIERS -> MODIFIERS [67:8]
        |       |   |--TYPE -> TYPE [67:8]
        |       |   |   `--LITERAL_INT -> int [67:8]
        |       |   |--IDENT -> success [67:12]
        |       |   `--ASSIGN -> = [67:20]
        |       |       `--EXPR -> EXPR [67:22]
        |       |           `--UNARY_MINUS -> - [67:22]
        |       |               `--NUM_INT -> 1 [67:23]
        |       |--SEMI -> ; [67:24]
        |       |--EXPR -> EXPR [68:16]
        |       |   `--ASSIGN -> = [68:16]
        |       |       |--IDENT -> success [68:8]
        |       |       `--LITERAL_SWITCH -> switch [68:18]
        |       |           |--LPAREN -> ( [68:24]
        |       |           |--EXPR -> EXPR [68:25]
        |       |           |   `--IDENT -> t [68:25]
        |       |           |--RPAREN -> ) [68:26]
        |       |           |--LCURLY -> { [68:28]
        |       |           |--CASE_GROUP -> CASE_GROUP [69:12]
        |       |           |   |--LITERAL_CASE -> case [69:12]
        |       |           |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [69:17]
        |       |           |   |   |   |--MODIFIERS -> MODIFIERS [69:17]
        |       |           |   |   |   |--TYPE -> TYPE [69:17]
        |       |           |   |   |   |   `--IDENT -> Box [69:17]
        |       |           |   |   |   |--LPAREN -> ( [69:20]
        |       |           |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [69:21]
        |       |           |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [69:21]
        |       |           |   |   |   |       |--MODIFIERS -> MODIFIERS [69:21]
        |       |           |   |   |   |       |--TYPE -> TYPE [69:21]
        |       |           |   |   |   |       |   `--IDENT -> R1 [69:21]
        |       |           |   |   |   |       `--IDENT -> _ [69:24]
        |       |           |   |   |   `--RPAREN -> ) [69:25]
        |       |           |   |   `--COLON -> : [69:27]
        |       |           |   `--SLIST -> SLIST [69:29]
        |       |           |       `--SLIST -> { [69:29]
        |       |           |           |--LITERAL_YIELD -> yield [70:16]
        |       |           |           |   |--EXPR -> EXPR [70:22]
        |       |           |           |   |   `--NUM_INT -> 1 [70:22]
        |       |           |           |   `--SEMI -> ; [70:23]
        |       |           |           `--RCURLY -> } [71:12]
        |       |           |--CASE_GROUP -> CASE_GROUP [72:12]
        |       |           |   |--LITERAL_CASE -> case [72:12]
        |       |           |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:17]
        |       |           |   |   |   |--MODIFIERS -> MODIFIERS [72:17]
        |       |           |   |   |   |--TYPE -> TYPE [72:17]
        |       |           |   |   |   |   `--IDENT -> Box [72:17]
        |       |           |   |   |   |--LPAREN -> ( [72:20]
        |       |           |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:21]
        |       |           |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [72:21]
        |       |           |   |   |   |       |--MODIFIERS -> MODIFIERS [72:21]
        |       |           |   |   |   |       |--TYPE -> TYPE [72:21]
        |       |           |   |   |   |       |   `--IDENT -> R2 [72:21]
        |       |           |   |   |   |       `--IDENT -> _ [72:24]
        |       |           |   |   |   `--RPAREN -> ) [72:25]
        |       |           |   |   |--COMMA -> , [72:26]
        |       |           |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:28]
        |       |           |   |   |   |--MODIFIERS -> MODIFIERS [72:28]
        |       |           |   |   |   |--TYPE -> TYPE [72:28]
        |       |           |   |   |   |   `--IDENT -> Box [72:28]
        |       |           |   |   |   |--LPAREN -> ( [72:31]
        |       |           |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:32]
        |       |           |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [72:32]
        |       |           |   |   |   |       |--MODIFIERS -> MODIFIERS [72:32]
        |       |           |   |   |   |       |--TYPE -> TYPE [72:32]
        |       |           |   |   |   |       |   `--IDENT -> var [72:32]
        |       |           |   |   |   |       `--IDENT -> _ [72:36]
        |       |           |   |   |   `--RPAREN -> ) [72:37]
        |       |           |   |   `--COLON -> : [72:39]
        |       |           |   `--SLIST -> SLIST [72:41]
        |       |           |       `--SLIST -> { [72:41]
        |       |           |           |--LITERAL_YIELD -> yield [73:16]
        |       |           |           |   |--EXPR -> EXPR [73:22]
        |       |           |           |   |   `--NUM_INT -> 2 [73:22]
        |       |           |           |   `--SEMI -> ; [73:23]
        |       |           |           `--RCURLY -> } [74:12]
        |       |           |--CASE_GROUP -> CASE_GROUP [75:12]
        |       |           |   |--LITERAL_DEFAULT -> default [75:12]
        |       |           |   |   `--COLON -> : [75:20]
        |       |           |   `--SLIST -> SLIST [75:22]
        |       |           |       `--SLIST -> { [75:22]
        |       |           |           |--LITERAL_YIELD -> yield [76:16]
        |       |           |           |   |--EXPR -> EXPR [76:22]
        |       |           |           |   |   `--UNARY_MINUS -> - [76:22]
        |       |           |           |   |       `--NUM_INT -> 2 [76:23]
        |       |           |           |   `--SEMI -> ; [76:24]
        |       |           |           `--RCURLY -> } [77:12]
        |       |           `--RCURLY -> } [78:8]
        |       |--SEMI -> ; [78:9]
        |       |--LITERAL_RETURN -> return [79:8]
        |       |   |--EXPR -> EXPR [79:15]
        |       |   |   `--IDENT -> success [79:15]
        |       |   `--SEMI -> ; [79:22]
        |       `--RCURLY -> } [80:4]
        |--METHOD_DEF -> METHOD_DEF [82:4]
        |   |--MODIFIERS -> MODIFIERS [82:4]
        |   |--TYPE -> TYPE [82:4]
        |   |   `--IDENT -> String [82:4]
        |   |--IDENT -> unnamedGuardAddsBindings [82:11]
        |   |--LPAREN -> ( [82:35]
        |   |--PARAMETERS -> PARAMETERS [82:36]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [82:36]
        |   |   |   |--MODIFIERS -> MODIFIERS [82:36]
        |   |   |   |--TYPE -> TYPE [82:36]
        |   |   |   |   `--IDENT -> Object [82:36]
        |   |   |   `--IDENT -> o1 [82:43]
        |   |   |--COMMA -> , [82:45]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [82:47]
        |   |       |--MODIFIERS -> MODIFIERS [82:47]
        |   |       |--TYPE -> TYPE [82:47]
        |   |       |   `--IDENT -> Object [82:47]
        |   |       `--IDENT -> o2 [82:54]
        |   |--RPAREN -> ) [82:56]
        |   `--SLIST -> { [82:58]
        |       |--LITERAL_RETURN -> return [83:8]
        |       |   |--EXPR -> EXPR [83:15]
        |       |   |   `--LITERAL_SWITCH -> switch [83:15]
        |       |   |       |--LPAREN -> ( [83:22]
        |       |   |       |--EXPR -> EXPR [83:23]
        |       |   |       |   `--IDENT -> o1 [83:23]
        |       |   |       |--RPAREN -> ) [83:25]
        |       |   |       |--LCURLY -> { [83:27]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [84:12]
        |       |   |       |   |--LITERAL_CASE -> case [84:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [84:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [84:17]
        |       |   |       |   |   |   |   `--IDENT -> String [84:17]
        |       |   |       |   |   |   `--IDENT -> _ [84:24]
        |       |   |       |   |   |--COMMA -> , [84:25]
        |       |   |       |   |   |--PATTERN_DEF -> PATTERN_DEF [84:36]
        |       |   |       |   |   |   `--LITERAL_WHEN -> when [84:36]
        |       |   |       |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:27]
        |       |   |       |   |   |       |   |--MODIFIERS -> MODIFIERS [84:27]
        |       |   |       |   |   |       |   |--TYPE -> TYPE [84:27]
        |       |   |       |   |   |       |   |   `--IDENT -> Object [84:27]
        |       |   |       |   |   |       |   `--IDENT -> _ [84:34]
        |       |   |       |   |   |       `--EXPR -> EXPR [84:44]
        |       |   |       |   |   |           `--LITERAL_INSTANCEOF -> instanceof [84:44]
        |       |   |       |   |   |               |--IDENT -> o2 [84:41]
        |       |   |       |   |   |               `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:55]
        |       |   |       |   |   |                   |--MODIFIERS -> MODIFIERS [84:55]
        |       |   |       |   |   |                   |--TYPE -> TYPE [84:55]
        |       |   |       |   |   |                   |   `--IDENT -> String [84:55]
        |       |   |       |   |   |                   `--IDENT -> s [84:62]
        |       |   |       |   |   `--COLON -> : [84:63]
        |       |   |       |   `--SLIST -> SLIST [84:65]
        |       |   |       |       `--LITERAL_YIELD -> yield [84:65]
        |       |   |       |           |--EXPR -> EXPR [84:71]
        |       |   |       |           |   `--IDENT -> s [84:71]
        |       |   |       |           `--SEMI -> ; [84:72]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [85:12]
        |       |   |       |   |--LITERAL_CASE -> case [85:12]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:17]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [85:17]
        |       |   |       |   |   |   |--TYPE -> TYPE [85:17]
        |       |   |       |   |   |   |   `--IDENT -> Object [85:17]
        |       |   |       |   |   |   `--IDENT -> _ [85:24]
        |       |   |       |   |   `--COLON -> : [85:25]
        |       |   |       |   `--SLIST -> SLIST [85:27]
        |       |   |       |       `--LITERAL_YIELD -> yield [85:27]
        |       |   |       |           |--EXPR -> EXPR [85:33]
        |       |   |       |           |   `--STRING_LITERAL -> "any" [85:33]
        |       |   |       |           `--SEMI -> ; [85:38]
        |       |   |       `--RCURLY -> } [86:8]
        |       |   `--SEMI -> ; [86:9]
        |       `--RCURLY -> } [87:4]
        |--METHOD_DEF -> METHOD_DEF [89:4]
        |   |--MODIFIERS -> MODIFIERS [89:4]
        |   |--TYPE -> TYPE [89:4]
        |   |   `--LITERAL_BOOLEAN -> boolean [89:4]
        |   |--IDENT -> testUnnamedPrimitiveAndExhaustiveness [89:12]
        |   |--LPAREN -> ( [89:49]
        |   |--PARAMETERS -> PARAMETERS [89:50]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [89:50]
        |   |       |--MODIFIERS -> MODIFIERS [89:50]
        |   |       |--TYPE -> TYPE [89:50]
        |   |       |   `--IDENT -> RecordWithPrimitive [89:50]
        |   |       `--IDENT -> a [89:70]
        |   |--RPAREN -> ) [89:71]
        |   `--SLIST -> { [89:73]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [90:8]
        |       |   |--MODIFIERS -> MODIFIERS [90:8]
        |       |   |--TYPE -> TYPE [90:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [90:8]
        |       |   |--IDENT -> r1 [90:16]
        |       |   `--ASSIGN -> = [90:19]
        |       |       `--EXPR -> EXPR [90:21]
        |       |           `--LITERAL_SWITCH -> switch [90:21]
        |       |               |--LPAREN -> ( [90:28]
        |       |               |--EXPR -> EXPR [90:29]
        |       |               |   `--IDENT -> a [90:29]
        |       |               |--RPAREN -> ) [90:30]
        |       |               |--LCURLY -> { [90:32]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [91:12]
        |       |               |   |--LITERAL_CASE -> case [91:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [91:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [91:17]
        |       |               |   |       |--TYPE -> TYPE [91:17]
        |       |               |   |       |   `--IDENT -> Prim1 [91:17]
        |       |               |   |       |--LPAREN -> ( [91:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [91:23]
        |       |               |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [91:23]
        |       |               |   |       |       |--MODIFIERS -> MODIFIERS [91:23]
        |       |               |   |       |       |--TYPE -> TYPE [91:23]
        |       |               |   |       |       |   `--IDENT -> var [91:23]
        |       |               |   |       |       `--IDENT -> _ [91:27]
        |       |               |   |       `--RPAREN -> ) [91:28]
        |       |               |   |--LAMBDA -> -> [91:30]
        |       |               |   |--EXPR -> EXPR [91:33]
        |       |               |   |   `--LITERAL_TRUE -> true [91:33]
        |       |               |   `--SEMI -> ; [91:37]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [92:12]
        |       |               |   |--LITERAL_CASE -> case [92:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [92:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [92:17]
        |       |               |   |       |--TYPE -> TYPE [92:17]
        |       |               |   |       |   `--IDENT -> Prim2 [92:17]
        |       |               |   |       |--LPAREN -> ( [92:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [92:23]
        |       |               |   |       |   `--UNNAMED_PATTERN_DEF -> _ [92:23]
        |       |               |   |       `--RPAREN -> ) [92:24]
        |       |               |   |--LAMBDA -> -> [92:26]
        |       |               |   |--EXPR -> EXPR [92:29]
        |       |               |   |   `--LITERAL_FALSE -> false [92:29]
        |       |               |   `--SEMI -> ; [92:34]
        |       |               `--RCURLY -> } [93:8]
        |       |--SEMI -> ; [93:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [95:8]
        |       |   |--MODIFIERS -> MODIFIERS [95:8]
        |       |   |--TYPE -> TYPE [95:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [95:8]
        |       |   |--IDENT -> r2 [95:16]
        |       |   `--ASSIGN -> = [95:19]
        |       |       `--EXPR -> EXPR [95:21]
        |       |           `--LITERAL_SWITCH -> switch [95:21]
        |       |               |--LPAREN -> ( [95:28]
        |       |               |--EXPR -> EXPR [95:29]
        |       |               |   `--IDENT -> a [95:29]
        |       |               |--RPAREN -> ) [95:30]
        |       |               |--LCURLY -> { [95:32]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [96:12]
        |       |               |   |--LITERAL_CASE -> case [96:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [96:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [96:17]
        |       |               |   |       |--TYPE -> TYPE [96:17]
        |       |               |   |       |   `--IDENT -> Prim1 [96:17]
        |       |               |   |       |--LPAREN -> ( [96:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [96:23]
        |       |               |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [96:23]
        |       |               |   |       |       |--MODIFIERS -> MODIFIERS [96:23]
        |       |               |   |       |       |--TYPE -> TYPE [96:23]
        |       |               |   |       |       |   `--IDENT -> var [96:23]
        |       |               |   |       |       `--IDENT -> _ [96:27]
        |       |               |   |       `--RPAREN -> ) [96:28]
        |       |               |   |--LAMBDA -> -> [96:30]
        |       |               |   |--EXPR -> EXPR [96:33]
        |       |               |   |   `--LITERAL_TRUE -> true [96:33]
        |       |               |   `--SEMI -> ; [96:37]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [97:12]
        |       |               |   |--LITERAL_CASE -> case [97:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [97:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [97:17]
        |       |               |   |       |--TYPE -> TYPE [97:17]
        |       |               |   |       |   `--IDENT -> Prim2 [97:17]
        |       |               |   |       |--LPAREN -> ( [97:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [97:23]
        |       |               |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [97:23]
        |       |               |   |       |       |--MODIFIERS -> MODIFIERS [97:23]
        |       |               |   |       |       |--TYPE -> TYPE [97:23]
        |       |               |   |       |       |   `--IDENT -> var [97:23]
        |       |               |   |       |       `--IDENT -> _ [97:27]
        |       |               |   |       `--RPAREN -> ) [97:28]
        |       |               |   |--LAMBDA -> -> [97:30]
        |       |               |   |--EXPR -> EXPR [97:33]
        |       |               |   |   `--LITERAL_FALSE -> false [97:33]
        |       |               |   `--SEMI -> ; [97:38]
        |       |               `--RCURLY -> } [98:8]
        |       |--SEMI -> ; [98:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [100:8]
        |       |   |--MODIFIERS -> MODIFIERS [100:8]
        |       |   |--TYPE -> TYPE [100:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [100:8]
        |       |   |--IDENT -> r3 [100:16]
        |       |   `--ASSIGN -> = [100:19]
        |       |       `--EXPR -> EXPR [100:21]
        |       |           `--LITERAL_SWITCH -> switch [100:21]
        |       |               |--LPAREN -> ( [100:28]
        |       |               |--EXPR -> EXPR [100:29]
        |       |               |   `--IDENT -> a [100:29]
        |       |               |--RPAREN -> ) [100:30]
        |       |               |--LCURLY -> { [100:32]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [101:12]
        |       |               |   |--LITERAL_CASE -> case [101:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [101:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [101:17]
        |       |               |   |       |--TYPE -> TYPE [101:17]
        |       |               |   |       |   `--IDENT -> Prim1 [101:17]
        |       |               |   |       |--LPAREN -> ( [101:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:23]
        |       |               |   |       |   `--UNNAMED_PATTERN_DEF -> _ [101:23]
        |       |               |   |       `--RPAREN -> ) [101:24]
        |       |               |   |--LAMBDA -> -> [101:26]
        |       |               |   |--EXPR -> EXPR [101:29]
        |       |               |   |   `--LITERAL_TRUE -> true [101:29]
        |       |               |   `--SEMI -> ; [101:33]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [102:12]
        |       |               |   |--LITERAL_CASE -> case [102:12]
        |       |               |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:17]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [102:17]
        |       |               |   |       |--TYPE -> TYPE [102:17]
        |       |               |   |       |   `--IDENT -> Prim2 [102:17]
        |       |               |   |       |--LPAREN -> ( [102:22]
        |       |               |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:23]
        |       |               |   |       |   `--UNNAMED_PATTERN_DEF -> _ [102:23]
        |       |               |   |       `--RPAREN -> ) [102:24]
        |       |               |   |--LAMBDA -> -> [102:26]
        |       |               |   |--EXPR -> EXPR [102:29]
        |       |               |   |   `--LITERAL_FALSE -> false [102:29]
        |       |               |   `--SEMI -> ; [102:34]
        |       |               `--RCURLY -> } [103:8]
        |       |--SEMI -> ; [103:9]
        |       |--LITERAL_RETURN -> return [105:8]
        |       |   |--EXPR -> EXPR [105:24]
        |       |   |   `--LAND -> && [105:24]
        |       |   |       |--LAND -> && [105:18]
        |       |   |       |   |--IDENT -> r1 [105:15]
        |       |   |       |   `--IDENT -> r2 [105:21]
        |       |   |       `--IDENT -> r3 [105:27]
        |       |   `--SEMI -> ; [105:29]
        |       `--RCURLY -> } [106:4]
        |--CLASS_DEF -> CLASS_DEF [108:4]
        |   |--MODIFIERS -> MODIFIERS [108:4]
        |   |   |--ABSTRACT -> abstract [108:4]
        |   |   `--LITERAL_SEALED -> sealed [108:13]
        |   |--LITERAL_CLASS -> class [108:20]
        |   |--IDENT -> Base [108:26]
        |   |--PERMITS_CLAUSE -> permits [108:31]
        |   |   |--IDENT -> R1 [108:39]
        |   |   |--COMMA -> , [108:41]
        |   |   |--IDENT -> R2 [108:43]
        |   |   |--COMMA -> , [108:45]
        |   |   |--IDENT -> R3 [108:47]
        |   |   |--COMMA -> , [108:49]
        |   |   `--IDENT -> R4 [108:51]
        |   `--OBJBLOCK -> OBJBLOCK [108:54]
        |       |--LCURLY -> { [108:54]
        |       `--RCURLY -> } [108:56]
        |--CLASS_DEF -> CLASS_DEF [109:4]
        |   |--MODIFIERS -> MODIFIERS [109:4]
        |   |   `--FINAL -> final [109:4]
        |   |--LITERAL_CLASS -> class [109:11]
        |   |--IDENT -> R1 [109:17]
        |   |--EXTENDS_CLAUSE -> extends [109:21]
        |   |   `--IDENT -> Base [109:29]
        |   `--OBJBLOCK -> OBJBLOCK [109:34]
        |       |--LCURLY -> { [109:34]
        |       `--RCURLY -> } [109:36]
        |--CLASS_DEF -> CLASS_DEF [110:4]
        |   |--MODIFIERS -> MODIFIERS [110:4]
        |   |   `--FINAL -> final [110:4]
        |   |--LITERAL_CLASS -> class [110:11]
        |   |--IDENT -> R2 [110:17]
        |   |--EXTENDS_CLAUSE -> extends [110:21]
        |   |   `--IDENT -> Base [110:29]
        |   `--OBJBLOCK -> OBJBLOCK [110:34]
        |       |--LCURLY -> { [110:34]
        |       `--RCURLY -> } [110:36]
        |--CLASS_DEF -> CLASS_DEF [111:4]
        |   |--MODIFIERS -> MODIFIERS [111:4]
        |   |   `--FINAL -> final [111:4]
        |   |--LITERAL_CLASS -> class [111:11]
        |   |--IDENT -> R3 [111:17]
        |   |--EXTENDS_CLAUSE -> extends [111:21]
        |   |   `--IDENT -> Base [111:29]
        |   `--OBJBLOCK -> OBJBLOCK [111:34]
        |       |--LCURLY -> { [111:34]
        |       `--RCURLY -> } [111:36]
        |--CLASS_DEF -> CLASS_DEF [112:4]
        |   |--MODIFIERS -> MODIFIERS [112:4]
        |   |   `--FINAL -> final [112:4]
        |   |--LITERAL_CLASS -> class [112:11]
        |   |--IDENT -> R4 [112:17]
        |   |--EXTENDS_CLAUSE -> extends [112:21]
        |   |   `--IDENT -> Base [112:29]
        |   `--OBJBLOCK -> OBJBLOCK [112:34]
        |       |--LCURLY -> { [112:34]
        |       `--RCURLY -> } [112:36]
        |--INTERFACE_DEF -> INTERFACE_DEF [113:4]
        |   |--MODIFIERS -> MODIFIERS [113:4]
        |   |   `--LITERAL_SEALED -> sealed [113:4]
        |   |--LITERAL_INTERFACE -> interface [113:11]
        |   |--IDENT -> RecordWithPrimitive [113:21]
        |   |--PERMITS_CLAUSE -> permits [113:41]
        |   |   |--IDENT -> Prim1 [113:49]
        |   |   |--COMMA -> , [113:54]
        |   |   `--IDENT -> Prim2 [113:56]
        |   `--OBJBLOCK -> OBJBLOCK [113:62]
        |       |--LCURLY -> { [113:62]
        |       `--RCURLY -> } [113:63]
        |--SEMI -> ; [113:64]
        |--RECORD_DEF -> RECORD_DEF [114:4]
        |   |--MODIFIERS -> MODIFIERS [114:4]
        |   |--LITERAL_RECORD -> record [114:4]
        |   |--IDENT -> Prim1 [114:11]
        |   |--LPAREN -> ( [114:16]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [114:17]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [114:17]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [114:17]
        |   |       |--TYPE -> TYPE [114:17]
        |   |       |   `--LITERAL_INT -> int [114:17]
        |   |       `--IDENT -> n1 [114:21]
        |   |--RPAREN -> ) [114:23]
        |   |--IMPLEMENTS_CLAUSE -> implements [114:25]
        |   |   `--IDENT -> RecordWithPrimitive [114:36]
        |   `--OBJBLOCK -> OBJBLOCK [114:56]
        |       |--LCURLY -> { [114:56]
        |       `--RCURLY -> } [114:57]
        |--SEMI -> ; [114:58]
        |--RECORD_DEF -> RECORD_DEF [115:4]
        |   |--MODIFIERS -> MODIFIERS [115:4]
        |   |--LITERAL_RECORD -> record [115:4]
        |   |--IDENT -> Prim2 [115:11]
        |   |--LPAREN -> ( [115:16]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [115:17]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [115:17]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [115:17]
        |   |       |--TYPE -> TYPE [115:17]
        |   |       |   `--LITERAL_INT -> int [115:17]
        |   |       `--IDENT -> n2 [115:21]
        |   |--RPAREN -> ) [115:23]
        |   |--IMPLEMENTS_CLAUSE -> implements [115:25]
        |   |   `--IDENT -> RecordWithPrimitive [115:36]
        |   `--OBJBLOCK -> OBJBLOCK [115:56]
        |       |--LCURLY -> { [115:56]
        |       `--RCURLY -> } [115:57]
        |--SEMI -> ; [115:58]
        |--RECORD_DEF -> RECORD_DEF [116:4]
        |   |--MODIFIERS -> MODIFIERS [116:4]
        |   |--LITERAL_RECORD -> record [116:4]
        |   |--IDENT -> Box [116:11]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [116:14]
        |   |   |--GENERIC_START -> < [116:14]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [116:15]
        |   |   |   |--IDENT -> T [116:15]
        |   |   |   `--TYPE_UPPER_BOUNDS -> extends [116:17]
        |   |   |       `--IDENT -> Base [116:25]
        |   |   `--GENERIC_END -> > [116:29]
        |   |--LPAREN -> ( [116:30]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [116:31]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [116:31]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [116:31]
        |   |       |--TYPE -> TYPE [116:31]
        |   |       |   `--IDENT -> T [116:31]
        |   |       `--IDENT -> content [116:33]
        |   |--RPAREN -> ) [116:40]
        |   `--OBJBLOCK -> OBJBLOCK [116:42]
        |       |--LCURLY -> { [116:42]
        |       `--RCURLY -> } [116:44]
        |--RECORD_DEF -> RECORD_DEF [117:4]
        |   |--MODIFIERS -> MODIFIERS [117:4]
        |   |--LITERAL_RECORD -> record [117:4]
        |   |--IDENT -> Box2 [117:11]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [117:15]
        |   |   |--GENERIC_START -> < [117:15]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [117:16]
        |   |   |   |--IDENT -> T [117:16]
        |   |   |   `--TYPE_UPPER_BOUNDS -> extends [117:18]
        |   |   |       `--IDENT -> Base [117:26]
        |   |   `--GENERIC_END -> > [117:30]
        |   |--LPAREN -> ( [117:31]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [117:32]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [117:32]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [117:32]
        |   |       |--TYPE -> TYPE [117:32]
        |   |       |   `--IDENT -> T [117:32]
        |   |       `--IDENT -> content [117:34]
        |   |--RPAREN -> ) [117:41]
        |   `--OBJBLOCK -> OBJBLOCK [117:43]
        |       |--LCURLY -> { [117:43]
        |       `--RCURLY -> } [117:45]
        `--RCURLY -> } [118:0]
