COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:40]
|   |--DOT -> . [1:40]
|   |   |--DOT -> . [1:29]
|   |   |   |--DOT -> . [1:23]
|   |   |   |   |--DOT -> . [1:12]
|   |   |   |   |   |--IDENT -> com [1:9]
|   |   |   |   |   `--IDENT -> puppycrawl [1:13]
|   |   |   |   `--IDENT -> tools [1:24]
|   |   |   `--IDENT -> checkstyle [1:30]
|   |   `--IDENT -> grammar [1:41]
|   `--SEMI -> ; [1:48]
|--IMPORT -> import [3:1]
|   |--DOT -> . [3:17]
|   |   |--DOT -> . [3:12]
|   |   |   |--IDENT -> java [3:8]
|   |   |   `--IDENT -> util [3:13]
|   |   `--IDENT -> ArrayList [3:18]
|   `--SEMI -> ; [3:27]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> LinkedList [4:18]
|   `--SEMI -> ; [4:28]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:17]
|   |   |--DOT -> . [5:12]
|   |   |   |--IDENT -> java [5:8]
|   |   |   `--IDENT -> util [5:13]
|   |   `--IDENT -> List [5:18]
|   `--SEMI -> ; [5:22]
|--IMPORT -> import [6:1]
|   |--DOT -> . [6:17]
|   |   |--DOT -> . [6:12]
|   |   |   |--IDENT -> java [6:8]
|   |   |   `--IDENT -> util [6:13]
|   |   `--IDENT -> Set [6:18]
|   `--SEMI -> ; [6:21]
|--CLASS_DEF -> CLASS_DEF [8:1]
|   |--MODIFIERS -> MODIFIERS [8:1]
|   |   `--LITERAL_PUBLIC -> public [8:1]
|   |--LITERAL_CLASS -> class [8:8]
|   |--IDENT -> InputPatternsInSwitchLabels [8:14]
|   `--OBJBLOCK -> OBJBLOCK [8:42]
|       |--LCURLY -> { [8:42]
|       |--METHOD_DEF -> METHOD_DEF [9:5]
|       |   |--MODIFIERS -> MODIFIERS [9:5]
|       |   |   `--LITERAL_STATIC -> static [9:5]
|       |   |--TYPE -> TYPE [9:12]
|       |   |   `--LITERAL_VOID -> void [9:12]
|       |   |--IDENT -> m1 [9:17]
|       |   |--LPAREN -> ( [9:19]
|       |   |--PARAMETERS -> PARAMETERS [9:20]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [9:20]
|       |   |       |--MODIFIERS -> MODIFIERS [9:20]
|       |   |       |--TYPE -> TYPE [9:20]
|       |   |       |   `--IDENT -> Object [9:20]
|       |   |       `--IDENT -> o [9:27]
|       |   |--RPAREN -> ) [9:28]
|       |   `--SLIST -> { [9:30]
|       |       |--LITERAL_SWITCH -> switch [11:9]
|       |       |   |--LPAREN -> ( [11:16]
|       |       |   |--EXPR -> EXPR [11:17]
|       |       |   |   `--IDENT -> o [11:17]
|       |       |   |--RPAREN -> ) [11:18]
|       |       |   |--LCURLY -> { [11:20]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [12:13]
|       |       |   |   |--LITERAL_CASE -> case [12:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [12:28]
|       |       |   |   |       `--LITERAL_WHEN -> when [12:28]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [12:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [12:18]
|       |       |   |   |           |   |--TYPE -> TYPE [12:18]
|       |       |   |   |           |   |   `--IDENT -> Integer [12:18]
|       |       |   |   |           |   `--IDENT -> i [12:26]
|       |       |   |   |           `--EXPR -> EXPR [12:35]
|       |       |   |   |               `--GE -> >= [12:35]
|       |       |   |   |                   |--IDENT -> i [12:33]
|       |       |   |   |                   `--NUM_INT -> 0 [12:38]
|       |       |   |   |--LAMBDA -> -> [12:40]
|       |       |   |   |--EXPR -> EXPR [12:61]
|       |       |   |   |   `--METHOD_CALL -> ( [12:61]
|       |       |   |   |       |--DOT -> . [12:53]
|       |       |   |   |       |   |--DOT -> . [12:49]
|       |       |   |   |       |   |   |--IDENT -> System [12:43]
|       |       |   |   |       |   |   `--IDENT -> out [12:50]
|       |       |   |   |       |   `--IDENT -> println [12:54]
|       |       |   |   |       |--ELIST -> ELIST [12:62]
|       |       |   |   |       |   `--EXPR -> EXPR [12:62]
|       |       |   |   |       |       `--IDENT -> i [12:62]
|       |       |   |   |       `--RPAREN -> ) [12:63]
|       |       |   |   `--SEMI -> ; [12:64]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [13:13]
|       |       |   |   |--LITERAL_CASE -> case [13:13]
|       |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [13:18]
|       |       |   |   |       |--MODIFIERS -> MODIFIERS [13:18]
|       |       |   |   |       |--TYPE -> TYPE [13:18]
|       |       |   |   |       |   `--IDENT -> Integer [13:18]
|       |       |   |   |       `--IDENT -> i [13:26]
|       |       |   |   |--LAMBDA -> -> [13:28]
|       |       |   |   |--EXPR -> EXPR [13:49]
|       |       |   |   |   `--METHOD_CALL -> ( [13:49]
|       |       |   |   |       |--DOT -> . [13:41]
|       |       |   |   |       |   |--DOT -> . [13:37]
|       |       |   |   |       |   |   |--IDENT -> System [13:31]
|       |       |   |   |       |   |   `--IDENT -> out [13:38]
|       |       |   |   |       |   `--IDENT -> println [13:42]
|       |       |   |   |       |--ELIST -> ELIST [13:52]
|       |       |   |   |       |   `--EXPR -> EXPR [13:52]
|       |       |   |   |       |       `--SL -> << [13:52]
|       |       |   |   |       |           |--IDENT -> i [13:50]
|       |       |   |   |       |           `--NUM_INT -> 1 [13:55]
|       |       |   |   |       `--RPAREN -> ) [13:56]
|       |       |   |   `--SEMI -> ; [13:57]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [14:13]
|       |       |   |   |--LITERAL_DEFAULT -> default [14:13]
|       |       |   |   |--LAMBDA -> -> [14:21]
|       |       |   |   `--LITERAL_THROW -> throw [14:24]
|       |       |   |       |--EXPR -> EXPR [14:30]
|       |       |   |       |   `--LITERAL_NEW -> new [14:30]
|       |       |   |       |       |--IDENT -> IllegalStateException [14:34]
|       |       |   |       |       |--LPAREN -> ( [14:55]
|       |       |   |       |       |--ELIST -> ELIST [15:42]
|       |       |   |       |       |   `--EXPR -> EXPR [15:42]
|       |       |   |       |       |       `--PLUS -> + [15:42]
|       |       |   |       |       |           |--STRING_LITERAL -> "Unexpected value: " [15:21]
|       |       |   |       |       |           `--IDENT -> o [15:44]
|       |       |   |       |       `--RPAREN -> ) [15:45]
|       |       |   |       `--SEMI -> ; [15:46]
|       |       |   `--RCURLY -> } [16:9]
|       |       `--RCURLY -> } [17:5]
|       |--METHOD_DEF -> METHOD_DEF [19:5]
|       |   |--MODIFIERS -> MODIFIERS [19:5]
|       |   |   `--LITERAL_STATIC -> static [19:5]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [19:12]
|       |   |   |--GENERIC_START -> < [19:12]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [19:13]
|       |   |   |   `--IDENT -> T [19:13]
|       |   |   `--GENERIC_END -> > [19:14]
|       |   |--TYPE -> TYPE [19:16]
|       |   |   `--LITERAL_VOID -> void [19:16]
|       |   |--IDENT -> m2 [19:21]
|       |   |--LPAREN -> ( [19:23]
|       |   |--PARAMETERS -> PARAMETERS [19:24]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [19:24]
|       |   |       |--MODIFIERS -> MODIFIERS [19:24]
|       |   |       |--TYPE -> TYPE [19:24]
|       |   |       |   `--IDENT -> Object [19:24]
|       |   |       `--IDENT -> o [19:31]
|       |   |--RPAREN -> ) [19:32]
|       |   `--SLIST -> { [19:34]
|       |       |--LITERAL_SWITCH -> switch [21:9]
|       |       |   |--LPAREN -> ( [21:16]
|       |       |   |--EXPR -> EXPR [21:17]
|       |       |   |   `--IDENT -> o [21:17]
|       |       |   |--RPAREN -> ) [21:18]
|       |       |   |--LCURLY -> { [21:20]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [22:13]
|       |       |   |   |--LITERAL_CASE -> case [22:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [22:29]
|       |       |   |   |       `--LITERAL_WHEN -> when [22:29]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [22:18]
|       |       |   |   |           |   |--TYPE -> TYPE [22:18]
|       |       |   |   |           |   |   `--IDENT -> List [22:18]
|       |       |   |   |           |   `--IDENT -> list1 [22:23]
|       |       |   |   |           `--EXPR -> EXPR [23:43]
|       |       |   |   |               `--LOR -> || [23:43]
|       |       |   |   |                   |--LPAREN -> ( [22:34]
|       |       |   |   |                   |--LAND -> && [23:21]
|       |       |   |   |                   |   |--GE -> >= [22:48]
|       |       |   |   |                   |   |   |--METHOD_CALL -> ( [22:45]
|       |       |   |   |                   |   |   |   |--DOT -> . [22:40]
|       |       |   |   |                   |   |   |   |   |--IDENT -> list1 [22:35]
|       |       |   |   |                   |   |   |   |   `--IDENT -> size [22:41]
|       |       |   |   |                   |   |   |   |--ELIST -> ELIST [22:46]
|       |       |   |   |                   |   |   |   `--RPAREN -> ) [22:46]
|       |       |   |   |                   |   |   `--NUM_INT -> 0 [22:51]
|       |       |   |   |                   |   `--LT -> < [23:37]
|       |       |   |   |                   |       |--METHOD_CALL -> ( [23:34]
|       |       |   |   |                   |       |   |--DOT -> . [23:29]
|       |       |   |   |                   |       |   |   |--IDENT -> list1 [23:24]
|       |       |   |   |                   |       |   |   `--IDENT -> size [23:30]
|       |       |   |   |                   |       |   |--ELIST -> ELIST [23:35]
|       |       |   |   |                   |       |   `--RPAREN -> ) [23:35]
|       |       |   |   |                   |       `--NUM_INT -> 10 [23:39]
|       |       |   |   |                   |--RPAREN -> ) [23:41]
|       |       |   |   |                   `--METHOD_CALL -> ( [23:58]
|       |       |   |   |                       |--DOT -> . [23:51]
|       |       |   |   |                       |   |--IDENT -> list1 [23:46]
|       |       |   |   |                       |   `--IDENT -> equals [23:52]
|       |       |   |   |                       |--ELIST -> ELIST [23:59]
|       |       |   |   |                       |   `--EXPR -> EXPR [23:59]
|       |       |   |   |                       |       `--LITERAL_NEW -> new [23:59]
|       |       |   |   |                       |           |--IDENT -> ArrayList [23:63]
|       |       |   |   |                       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:72]
|       |       |   |   |                       |           |   |--GENERIC_START -> < [23:72]
|       |       |   |   |                       |           |   `--GENERIC_END -> > [23:73]
|       |       |   |   |                       |           |--LPAREN -> ( [23:74]
|       |       |   |   |                       |           |--ELIST -> ELIST [23:75]
|       |       |   |   |                       |           `--RPAREN -> ) [23:75]
|       |       |   |   |                       `--RPAREN -> ) [23:76]
|       |       |   |   |--LAMBDA -> -> [23:78]
|       |       |   |   |--EXPR -> EXPR [24:39]
|       |       |   |   |   `--METHOD_CALL -> ( [24:39]
|       |       |   |   |       |--DOT -> . [24:31]
|       |       |   |   |       |   |--DOT -> . [24:27]
|       |       |   |   |       |   |   |--IDENT -> System [24:21]
|       |       |   |   |       |   |   `--IDENT -> out [24:28]
|       |       |   |   |       |   `--IDENT -> println [24:32]
|       |       |   |   |       |--ELIST -> ELIST [24:40]
|       |       |   |   |       |   `--EXPR -> EXPR [24:40]
|       |       |   |   |       |       `--IDENT -> list1 [24:40]
|       |       |   |   |       `--RPAREN -> ) [24:45]
|       |       |   |   `--SEMI -> ; [24:46]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [25:13]
|       |       |   |   |--LITERAL_CASE -> case [25:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [25:29]
|       |       |   |   |       `--LITERAL_WHEN -> when [25:29]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [25:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [25:18]
|       |       |   |   |           |   |--TYPE -> TYPE [25:18]
|       |       |   |   |           |   |   `--IDENT -> List [25:18]
|       |       |   |   |           |   `--IDENT -> list2 [25:23]
|       |       |   |   |           `--EXPR -> EXPR [26:43]
|       |       |   |   |               `--LOR -> || [26:43]
|       |       |   |   |                   |--LPAREN -> ( [25:34]
|       |       |   |   |                   |--LAND -> && [26:21]
|       |       |   |   |                   |   |--GE -> >= [25:48]
|       |       |   |   |                   |   |   |--METHOD_CALL -> ( [25:45]
|       |       |   |   |                   |   |   |   |--DOT -> . [25:40]
|       |       |   |   |                   |   |   |   |   |--IDENT -> list2 [25:35]
|       |       |   |   |                   |   |   |   |   `--IDENT -> size [25:41]
|       |       |   |   |                   |   |   |   |--ELIST -> ELIST [25:46]
|       |       |   |   |                   |   |   |   `--RPAREN -> ) [25:46]
|       |       |   |   |                   |   |   `--NUM_INT -> 0 [25:51]
|       |       |   |   |                   |   `--LT -> < [26:37]
|       |       |   |   |                   |       |--METHOD_CALL -> ( [26:34]
|       |       |   |   |                   |       |   |--DOT -> . [26:29]
|       |       |   |   |                   |       |   |   |--IDENT -> list2 [26:24]
|       |       |   |   |                   |       |   |   `--IDENT -> size [26:30]
|       |       |   |   |                   |       |   |--ELIST -> ELIST [26:35]
|       |       |   |   |                   |       |   `--RPAREN -> ) [26:35]
|       |       |   |   |                   |       `--NUM_INT -> 20 [26:39]
|       |       |   |   |                   |--RPAREN -> ) [26:41]
|       |       |   |   |                   `--METHOD_CALL -> ( [26:58]
|       |       |   |   |                       |--DOT -> . [26:51]
|       |       |   |   |                       |   |--IDENT -> list2 [26:46]
|       |       |   |   |                       |   `--IDENT -> equals [26:52]
|       |       |   |   |                       |--ELIST -> ELIST [26:59]
|       |       |   |   |                       |   `--EXPR -> EXPR [26:59]
|       |       |   |   |                       |       `--LITERAL_NEW -> new [26:59]
|       |       |   |   |                       |           |--IDENT -> LinkedList [26:63]
|       |       |   |   |                       |           |--LPAREN -> ( [26:73]
|       |       |   |   |                       |           |--ELIST -> ELIST [26:74]
|       |       |   |   |                       |           `--RPAREN -> ) [26:74]
|       |       |   |   |                       `--RPAREN -> ) [26:75]
|       |       |   |   |--LAMBDA -> -> [26:77]
|       |       |   |   |--EXPR -> EXPR [27:39]
|       |       |   |   |   `--METHOD_CALL -> ( [27:39]
|       |       |   |   |       |--DOT -> . [27:31]
|       |       |   |   |       |   |--DOT -> . [27:27]
|       |       |   |   |       |   |   |--IDENT -> System [27:21]
|       |       |   |   |       |   |   `--IDENT -> out [27:28]
|       |       |   |   |       |   `--IDENT -> println [27:32]
|       |       |   |   |       |--ELIST -> ELIST [27:40]
|       |       |   |   |       |   `--EXPR -> EXPR [27:40]
|       |       |   |   |       |       `--STRING_LITERAL -> "list2" [27:40]
|       |       |   |   |       `--RPAREN -> ) [27:47]
|       |       |   |   `--SEMI -> ; [27:48]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [28:13]
|       |       |   |   |--LITERAL_CASE -> case [28:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [28:29]
|       |       |   |   |       `--LITERAL_WHEN -> when [28:29]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [28:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [28:18]
|       |       |   |   |           |   |--TYPE -> TYPE [28:18]
|       |       |   |   |           |   |   `--IDENT -> List [28:18]
|       |       |   |   |           |   `--IDENT -> list3 [28:23]
|       |       |   |   |           `--EXPR -> EXPR [29:42]
|       |       |   |   |               `--LOR -> || [29:42]
|       |       |   |   |                   |--LAND -> && [29:21]
|       |       |   |   |                   |   |--GE -> >= [28:47]
|       |       |   |   |                   |   |   |--METHOD_CALL -> ( [28:44]
|       |       |   |   |                   |   |   |   |--DOT -> . [28:39]
|       |       |   |   |                   |   |   |   |   |--IDENT -> list3 [28:34]
|       |       |   |   |                   |   |   |   |   `--IDENT -> size [28:40]
|       |       |   |   |                   |   |   |   |--ELIST -> ELIST [28:45]
|       |       |   |   |                   |   |   |   `--RPAREN -> ) [28:45]
|       |       |   |   |                   |   |   `--NUM_INT -> 0 [28:50]
|       |       |   |   |                   |   `--LT -> < [29:37]
|       |       |   |   |                   |       |--METHOD_CALL -> ( [29:34]
|       |       |   |   |                   |       |   |--DOT -> . [29:29]
|       |       |   |   |                   |       |   |   |--IDENT -> list3 [29:24]
|       |       |   |   |                   |       |   |   `--IDENT -> size [29:30]
|       |       |   |   |                   |       |   |--ELIST -> ELIST [29:35]
|       |       |   |   |                   |       |   `--RPAREN -> ) [29:35]
|       |       |   |   |                   |       `--NUM_INT -> 45 [29:39]
|       |       |   |   |                   `--METHOD_CALL -> ( [29:57]
|       |       |   |   |                       |--DOT -> . [29:50]
|       |       |   |   |                       |   |--IDENT -> list3 [29:45]
|       |       |   |   |                       |   `--IDENT -> equals [29:51]
|       |       |   |   |                       |--ELIST -> ELIST [29:58]
|       |       |   |   |                       |   `--EXPR -> EXPR [29:58]
|       |       |   |   |                       |       `--LITERAL_NEW -> new [29:58]
|       |       |   |   |                       |           |--IDENT -> LinkedList [29:62]
|       |       |   |   |                       |           |--LPAREN -> ( [29:72]
|       |       |   |   |                       |           |--ELIST -> ELIST [29:73]
|       |       |   |   |                       |           `--RPAREN -> ) [29:73]
|       |       |   |   |                       `--RPAREN -> ) [29:74]
|       |       |   |   |--LAMBDA -> -> [29:76]
|       |       |   |   |--EXPR -> EXPR [30:39]
|       |       |   |   |   `--METHOD_CALL -> ( [30:39]
|       |       |   |   |       |--DOT -> . [30:31]
|       |       |   |   |       |   |--DOT -> . [30:27]
|       |       |   |   |       |   |   |--IDENT -> System [30:21]
|       |       |   |   |       |   |   `--IDENT -> out [30:28]
|       |       |   |   |       |   `--IDENT -> println [30:32]
|       |       |   |   |       |--ELIST -> ELIST [30:40]
|       |       |   |   |       |   `--EXPR -> EXPR [30:40]
|       |       |   |   |       |       `--STRING_LITERAL -> "list3" [30:40]
|       |       |   |   |       `--RPAREN -> ) [30:47]
|       |       |   |   `--SEMI -> ; [30:48]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [31:13]
|       |       |   |   |--LITERAL_CASE -> case [31:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [31:26]
|       |       |   |   |       `--LITERAL_WHEN -> when [31:26]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [31:18]
|       |       |   |   |           |   |--TYPE -> TYPE [31:18]
|       |       |   |   |           |   |   `--IDENT -> Set [31:18]
|       |       |   |   |           |   `--IDENT -> set [31:22]
|       |       |   |   |           `--EXPR -> EXPR [31:44]
|       |       |   |   |               `--METHOD_CALL -> ( [31:44]
|       |       |   |   |                   |--DOT -> . [31:37]
|       |       |   |   |                   |   |--STRING_LITERAL -> "test" [31:31]
|       |       |   |   |                   |   `--IDENT -> equals [31:38]
|       |       |   |   |                   |--ELIST -> ELIST [31:57]
|       |       |   |   |                   |   `--EXPR -> EXPR [31:57]
|       |       |   |   |                   |       `--METHOD_CALL -> ( [31:57]
|       |       |   |   |                   |           |--DOT -> . [31:48]
|       |       |   |   |                   |           |   |--IDENT -> set [31:45]
|       |       |   |   |                   |           |   `--IDENT -> toString [31:49]
|       |       |   |   |                   |           |--ELIST -> ELIST [31:58]
|       |       |   |   |                   |           `--RPAREN -> ) [31:58]
|       |       |   |   |                   `--RPAREN -> ) [31:59]
|       |       |   |   |--LAMBDA -> -> [31:61]
|       |       |   |   |--EXPR -> EXPR [32:39]
|       |       |   |   |   `--METHOD_CALL -> ( [32:39]
|       |       |   |   |       |--DOT -> . [32:31]
|       |       |   |   |       |   |--DOT -> . [32:27]
|       |       |   |   |       |   |   |--IDENT -> System [32:21]
|       |       |   |   |       |   |   `--IDENT -> out [32:28]
|       |       |   |   |       |   `--IDENT -> println [32:32]
|       |       |   |   |       |--ELIST -> ELIST [32:40]
|       |       |   |   |       |   `--EXPR -> EXPR [32:40]
|       |       |   |   |       |       `--IDENT -> set [32:40]
|       |       |   |   |       `--RPAREN -> ) [32:43]
|       |       |   |   `--SEMI -> ; [32:44]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [33:13]
|       |       |   |   |--LITERAL_DEFAULT -> default [33:13]
|       |       |   |   |--LAMBDA -> -> [33:21]
|       |       |   |   `--LITERAL_THROW -> throw [33:24]
|       |       |   |       |--EXPR -> EXPR [33:30]
|       |       |   |       |   `--LITERAL_NEW -> new [33:30]
|       |       |   |       |       |--IDENT -> IllegalStateException [33:34]
|       |       |   |       |       |--LPAREN -> ( [33:55]
|       |       |   |       |       |--ELIST -> ELIST [34:42]
|       |       |   |       |       |   `--EXPR -> EXPR [34:42]
|       |       |   |       |       |       `--PLUS -> + [34:42]
|       |       |   |       |       |           |--STRING_LITERAL -> "Unexpected value: " [34:21]
|       |       |   |       |       |           `--IDENT -> o [34:44]
|       |       |   |       |       `--RPAREN -> ) [34:45]
|       |       |   |       `--SEMI -> ; [34:46]
|       |       |   `--RCURLY -> } [35:9]
|       |       `--RCURLY -> } [36:5]
|       |--METHOD_DEF -> METHOD_DEF [38:5]
|       |   |--MODIFIERS -> MODIFIERS [38:5]
|       |   |   `--LITERAL_STATIC -> static [38:5]
|       |   |--TYPE -> TYPE [38:12]
|       |   |   `--IDENT -> String [38:12]
|       |   |--IDENT -> m3 [38:19]
|       |   |--LPAREN -> ( [38:21]
|       |   |--PARAMETERS -> PARAMETERS [38:22]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:22]
|       |   |       |--MODIFIERS -> MODIFIERS [38:22]
|       |   |       |--TYPE -> TYPE [38:22]
|       |   |       |   `--IDENT -> Object [38:22]
|       |   |       `--IDENT -> o [38:29]
|       |   |--RPAREN -> ) [38:30]
|       |   `--SLIST -> { [38:32]
|       |       |--LITERAL_RETURN -> return [40:9]
|       |       |   |--EXPR -> EXPR [40:16]
|       |       |   |   `--LITERAL_SWITCH -> switch [40:16]
|       |       |   |       |--LPAREN -> ( [40:23]
|       |       |   |       |--EXPR -> EXPR [40:24]
|       |       |   |       |   `--IDENT -> o [40:24]
|       |       |   |       |--RPAREN -> ) [40:25]
|       |       |   |       |--LCURLY -> { [40:27]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [41:13]
|       |       |   |       |   |--LITERAL_CASE -> case [41:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [41:29]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [41:29]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [41:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [41:18]
|       |       |   |       |   |           |   |   `--IDENT -> List [41:18]
|       |       |   |       |   |           |   `--IDENT -> list1 [41:23]
|       |       |   |       |   |           `--EXPR -> EXPR [42:21]
|       |       |   |       |   |               `--LOR -> || [42:21]
|       |       |   |       |   |                   |--GE -> >= [41:47]
|       |       |   |       |   |                   |   |--METHOD_CALL -> ( [41:44]
|       |       |   |       |   |                   |   |   |--DOT -> . [41:39]
|       |       |   |       |   |                   |   |   |   |--IDENT -> list1 [41:34]
|       |       |   |       |   |                   |   |   |   `--IDENT -> size [41:40]
|       |       |   |       |   |                   |   |   |--ELIST -> ELIST [41:45]
|       |       |   |       |   |                   |   |   `--RPAREN -> ) [41:45]
|       |       |   |       |   |                   |   `--NUM_INT -> 0 [41:50]
|       |       |   |       |   |                   `--LT -> < [42:37]
|       |       |   |       |   |                       |--METHOD_CALL -> ( [42:34]
|       |       |   |       |   |                       |   |--DOT -> . [42:29]
|       |       |   |       |   |                       |   |   |--IDENT -> list1 [42:24]
|       |       |   |       |   |                       |   |   `--IDENT -> size [42:30]
|       |       |   |       |   |                       |   |--ELIST -> ELIST [42:35]
|       |       |   |       |   |                       |   `--RPAREN -> ) [42:35]
|       |       |   |       |   |                       `--NUM_INT -> 20 [42:39]
|       |       |   |       |   |--LAMBDA -> -> [42:42]
|       |       |   |       |   `--SLIST -> { [42:45]
|       |       |   |       |       |--LITERAL_YIELD -> yield [43:17]
|       |       |   |       |       |   |--EXPR -> EXPR [43:23]
|       |       |   |       |       |   |   `--STRING_LITERAL -> "list1!" [43:23]
|       |       |   |       |       |   `--SEMI -> ; [43:31]
|       |       |   |       |       `--RCURLY -> } [44:13]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [45:13]
|       |       |   |       |   |--LITERAL_CASE -> case [45:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [45:29]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [45:29]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [45:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [45:18]
|       |       |   |       |   |           |   |   `--IDENT -> List [45:18]
|       |       |   |       |   |           |   `--IDENT -> list1 [45:23]
|       |       |   |       |   |           `--EXPR -> EXPR [46:21]
|       |       |   |       |   |               `--LOR -> || [46:21]
|       |       |   |       |   |                   |--GE -> >= [45:47]
|       |       |   |       |   |                   |   |--METHOD_CALL -> ( [45:44]
|       |       |   |       |   |                   |   |   |--DOT -> . [45:39]
|       |       |   |       |   |                   |   |   |   |--IDENT -> list1 [45:34]
|       |       |   |       |   |                   |   |   |   `--IDENT -> size [45:40]
|       |       |   |       |   |                   |   |   |--ELIST -> ELIST [45:45]
|       |       |   |       |   |                   |   |   `--RPAREN -> ) [45:45]
|       |       |   |       |   |                   |   `--NUM_INT -> 0 [45:50]
|       |       |   |       |   |                   `--LT -> < [46:37]
|       |       |   |       |   |                       |--METHOD_CALL -> ( [46:34]
|       |       |   |       |   |                       |   |--DOT -> . [46:29]
|       |       |   |       |   |                       |   |   |--IDENT -> list1 [46:24]
|       |       |   |       |   |                       |   |   `--IDENT -> size [46:30]
|       |       |   |       |   |                       |   |--ELIST -> ELIST [46:35]
|       |       |   |       |   |                       |   `--RPAREN -> ) [46:35]
|       |       |   |       |   |                       `--NUM_INT -> 50 [46:39]
|       |       |   |       |   |--LAMBDA -> -> [46:42]
|       |       |   |       |   |--EXPR -> EXPR [46:45]
|       |       |   |       |   |   `--STRING_LITERAL -> "list1!" [46:45]
|       |       |   |       |   `--SEMI -> ; [46:53]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [48:13]
|       |       |   |       |   |--LITERAL_CASE -> case [48:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [48:29]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [48:29]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [48:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [48:18]
|       |       |   |       |   |           |   |   `--IDENT -> Integer [48:18]
|       |       |   |       |   |           |   `--IDENT -> i1 [48:26]
|       |       |   |       |   |           `--EXPR -> EXPR [48:41]
|       |       |   |       |   |               `--LAND -> && [48:41]
|       |       |   |       |   |                   |--LT -> < [48:37]
|       |       |   |       |   |                   |   |--IDENT -> i1 [48:34]
|       |       |   |       |   |                   |   `--NUM_INT -> 3 [48:39]
|       |       |   |       |   |                   `--GT -> > [48:47]
|       |       |   |       |   |                       |--IDENT -> i1 [48:44]
|       |       |   |       |   |                       `--NUM_INT -> 0 [48:49]
|       |       |   |       |   |--LAMBDA -> -> [48:51]
|       |       |   |       |   |--EXPR -> EXPR [48:54]
|       |       |   |       |   |   `--STRING_LITERAL -> "small integer!" [48:54]
|       |       |   |       |   `--SEMI -> ; [48:70]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [49:13]
|       |       |   |       |   |--LITERAL_CASE -> case [49:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [49:29]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [49:29]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [49:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [49:18]
|       |       |   |       |   |           |   |   `--IDENT -> Integer [49:18]
|       |       |   |       |   |           |   `--IDENT -> i2 [49:26]
|       |       |   |       |   |           `--EXPR -> EXPR [49:41]
|       |       |   |       |   |               `--LOR -> || [49:41]
|       |       |   |       |   |                   |--LT -> < [49:37]
|       |       |   |       |   |                   |   |--IDENT -> i2 [49:34]
|       |       |   |       |   |                   |   `--NUM_INT -> 0 [49:39]
|       |       |   |       |   |                   `--LT -> < [49:47]
|       |       |   |       |   |                       |--IDENT -> i2 [49:44]
|       |       |   |       |   |                       `--UNARY_MINUS -> - [49:49]
|       |       |   |       |   |                           `--NUM_INT -> 5 [49:50]
|       |       |   |       |   |--LAMBDA -> -> [49:52]
|       |       |   |       |   |--EXPR -> EXPR [49:55]
|       |       |   |       |   |   `--STRING_LITERAL -> "small negative integer!" [49:55]
|       |       |   |       |   `--SEMI -> ; [49:80]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [50:13]
|       |       |   |       |   |--LITERAL_CASE -> case [50:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [50:23]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [50:23]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [50:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [50:18]
|       |       |   |       |   |           |   |   `--IDENT -> AA [50:18]
|       |       |   |       |   |           |   `--IDENT -> a [50:21]
|       |       |   |       |   |           `--EXPR -> EXPR [50:46]
|       |       |   |       |   |               `--LAND -> && [50:46]
|       |       |   |       |   |                   |--LITERAL_INSTANCEOF -> instanceof [50:30]
|       |       |   |       |   |                   |   |--IDENT -> a [50:28]
|       |       |   |       |   |                   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:41]
|       |       |   |       |   |                   |       |--MODIFIERS -> MODIFIERS [50:41]
|       |       |   |       |   |                   |       |--TYPE -> TYPE [50:41]
|       |       |   |       |   |                   |       |   `--IDENT -> BB [50:41]
|       |       |   |       |   |                   |       `--IDENT -> b [50:44]
|       |       |   |       |   |                   `--EQUAL -> == [50:53]
|       |       |   |       |   |                       |--DOT -> . [50:50]
|       |       |   |       |   |                       |   |--IDENT -> b [50:49]
|       |       |   |       |   |                       |   `--IDENT -> f [50:51]
|       |       |   |       |   |                       `--NUM_INT -> 2 [50:56]
|       |       |   |       |   |--LAMBDA -> -> [50:58]
|       |       |   |       |   |--EXPR -> EXPR [51:21]
|       |       |   |       |   |   `--STRING_LITERAL -> "it's a 'b'!" [51:21]
|       |       |   |       |   `--SEMI -> ; [51:34]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [52:13]
|       |       |   |       |   |--LITERAL_CASE -> case [52:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [52:23]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [52:23]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [52:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [52:18]
|       |       |   |       |   |           |   |   `--IDENT -> AA [52:18]
|       |       |   |       |   |           |   `--IDENT -> a [52:21]
|       |       |   |       |   |           `--EXPR -> EXPR [52:49]
|       |       |   |       |   |               `--LOR -> || [52:49]
|       |       |   |       |   |                   |--LNOT -> ! [52:28]
|       |       |   |       |   |                   |   |--LPAREN -> ( [52:29]
|       |       |   |       |   |                   |   |--LITERAL_INSTANCEOF -> instanceof [52:32]
|       |       |   |       |   |                   |   |   |--IDENT -> a [52:30]
|       |       |   |       |   |                   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:43]
|       |       |   |       |   |                   |   |       |--MODIFIERS -> MODIFIERS [52:43]
|       |       |   |       |   |                   |   |       |--TYPE -> TYPE [52:43]
|       |       |   |       |   |                   |   |       |   `--IDENT -> BB [52:43]
|       |       |   |       |   |                   |   |       `--IDENT -> b [52:46]
|       |       |   |       |   |                   |   `--RPAREN -> ) [52:47]
|       |       |   |       |   |                   `--LAND -> && [52:72]
|       |       |   |       |   |                       |--LITERAL_INSTANCEOF -> instanceof [52:54]
|       |       |   |       |   |                       |   |--IDENT -> a [52:52]
|       |       |   |       |   |                       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:65]
|       |       |   |       |   |                       |       |--MODIFIERS -> MODIFIERS [52:65]
|       |       |   |       |   |                       |       |--TYPE -> TYPE [52:65]
|       |       |   |       |   |                       |       |   `--IDENT -> BB [52:65]
|       |       |   |       |   |                       |       `--IDENT -> b1 [52:69]
|       |       |   |       |   |                       `--LT -> < [52:79]
|       |       |   |       |   |                           |--DOT -> . [52:76]
|       |       |   |       |   |                           |   |--IDENT -> b [52:75]
|       |       |   |       |   |                           |   `--IDENT -> f [52:77]
|       |       |   |       |   |                           `--NUM_INT -> 0 [52:81]
|       |       |   |       |   |--LAMBDA -> -> [52:83]
|       |       |   |       |   |--EXPR -> EXPR [53:21]
|       |       |   |       |   |   `--STRING_LITERAL -> "it's not a 'b' or it's a negative 'b'" [53:21]
|       |       |   |       |   `--SEMI -> ; [53:60]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [54:13]
|       |       |   |       |   |--LITERAL_CASE -> case [54:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [54:23]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [54:23]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [54:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [54:18]
|       |       |   |       |   |           |   |   `--IDENT -> AA [54:18]
|       |       |   |       |   |           |   `--IDENT -> a [54:21]
|       |       |   |       |   |           `--EXPR -> EXPR [54:49]
|       |       |   |       |   |               `--LOR -> || [54:49]
|       |       |   |       |   |                   |--LNOT -> ! [54:28]
|       |       |   |       |   |                   |   |--LPAREN -> ( [54:29]
|       |       |   |       |   |                   |   |--LITERAL_INSTANCEOF -> instanceof [54:32]
|       |       |   |       |   |                   |   |   |--IDENT -> a [54:30]
|       |       |   |       |   |                   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:43]
|       |       |   |       |   |                   |   |       |--MODIFIERS -> MODIFIERS [54:43]
|       |       |   |       |   |                   |   |       |--TYPE -> TYPE [54:43]
|       |       |   |       |   |                   |   |       |   `--IDENT -> BB [54:43]
|       |       |   |       |   |                   |   |       `--IDENT -> b [54:46]
|       |       |   |       |   |                   |   `--RPAREN -> ) [54:47]
|       |       |   |       |   |                   `--LAND -> && [54:71]
|       |       |   |       |   |                       |--LITERAL_INSTANCEOF -> instanceof [54:54]
|       |       |   |       |   |                       |   |--IDENT -> a [54:52]
|       |       |   |       |   |                       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:65]
|       |       |   |       |   |                       |       |--MODIFIERS -> MODIFIERS [54:65]
|       |       |   |       |   |                       |       |--TYPE -> TYPE [54:65]
|       |       |   |       |   |                       |       |   `--IDENT -> BB [54:65]
|       |       |   |       |   |                       |       `--IDENT -> b2 [54:68]
|       |       |   |       |   |                       `--LT -> < [54:78]
|       |       |   |       |   |                           |--DOT -> . [54:75]
|       |       |   |       |   |                           |   |--IDENT -> b [54:74]
|       |       |   |       |   |                           |   `--IDENT -> f [54:76]
|       |       |   |       |   |                           `--UNARY_MINUS -> - [54:80]
|       |       |   |       |   |                               `--NUM_INT -> 5 [54:81]
|       |       |   |       |   |--LAMBDA -> -> [54:83]
|       |       |   |       |   |--EXPR -> EXPR [55:21]
|       |       |   |       |   |   `--STRING_LITERAL -> "it's not a 'b' or it's a negative 'b'..." [55:21]
|       |       |   |       |   `--SEMI -> ; [55:63]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [56:13]
|       |       |   |       |   |--LITERAL_CASE -> case [56:13]
|       |       |   |       |   |   `--EXPR -> EXPR [56:18]
|       |       |   |       |   |       `--LITERAL_NULL -> null [56:18]
|       |       |   |       |   |--LAMBDA -> -> [56:23]
|       |       |   |       |   |--EXPR -> EXPR [56:26]
|       |       |   |       |   |   `--STRING_LITERAL -> "it's null!" [56:26]
|       |       |   |       |   `--SEMI -> ; [56:38]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [57:13]
|       |       |   |       |   |--LITERAL_DEFAULT -> default [57:13]
|       |       |   |       |   |--LAMBDA -> -> [57:21]
|       |       |   |       |   `--LITERAL_THROW -> throw [57:24]
|       |       |   |       |       |--EXPR -> EXPR [57:30]
|       |       |   |       |       |   `--LITERAL_NEW -> new [57:30]
|       |       |   |       |       |       |--IDENT -> IllegalStateException [57:34]
|       |       |   |       |       |       |--LPAREN -> ( [57:55]
|       |       |   |       |       |       |--ELIST -> ELIST [58:42]
|       |       |   |       |       |       |   `--EXPR -> EXPR [58:42]
|       |       |   |       |       |       |       `--PLUS -> + [58:42]
|       |       |   |       |       |       |           |--STRING_LITERAL -> "Unexpected value: " [58:21]
|       |       |   |       |       |       |           `--IDENT -> o [58:44]
|       |       |   |       |       |       `--RPAREN -> ) [58:45]
|       |       |   |       |       `--SEMI -> ; [58:46]
|       |       |   |       `--RCURLY -> } [59:9]
|       |       |   `--SEMI -> ; [59:10]
|       |       `--RCURLY -> } [60:5]
|       `--RCURLY -> } [62:1]
|--CLASS_DEF -> CLASS_DEF [64:1]
|   |--MODIFIERS -> MODIFIERS [64:1]
|   |   `--LITERAL_SEALED -> sealed [64:1]
|   |--LITERAL_CLASS -> class [64:8]
|   |--IDENT -> AA [64:14]
|   |--PERMITS_CLAUSE -> permits [64:17]
|   |   `--IDENT -> BB [64:25]
|   `--OBJBLOCK -> OBJBLOCK [64:28]
|       |--LCURLY -> { [64:28]
|       `--RCURLY -> } [66:1]
`--CLASS_DEF -> CLASS_DEF [68:1]
    |--MODIFIERS -> MODIFIERS [68:1]
    |   `--LITERAL_NON_SEALED -> non-sealed [68:1]
    |--LITERAL_CLASS -> class [68:12]
    |--IDENT -> BB [68:18]
    |--EXTENDS_CLAUSE -> extends [68:21]
    |   `--IDENT -> AA [68:29]
    `--OBJBLOCK -> OBJBLOCK [68:32]
        |--LCURLY -> { [68:32]
        |--VARIABLE_DEF -> VARIABLE_DEF [69:5]
        |   |--MODIFIERS -> MODIFIERS [69:5]
        |   |   `--LITERAL_PUBLIC -> public [69:5]
        |   |--TYPE -> TYPE [69:12]
        |   |   `--LITERAL_INT -> int [69:12]
        |   |--IDENT -> f [69:16]
        |   |--ASSIGN -> = [69:18]
        |   |   `--EXPR -> EXPR [69:20]
        |   |       `--NUM_INT -> 2 [69:20]
        |   `--SEMI -> ; [69:21]
        `--RCURLY -> } [70:1]
