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