COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:48]
|   |--DOT -> . [1:48]
|   |   |--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]
|   |   `--IDENT -> antlr4 [1:49]
|   `--SEMI -> ; [1:55]
`--CLASS_DEF -> CLASS_DEF [3:1]
    |--MODIFIERS -> MODIFIERS [3:1]
    |   `--LITERAL_PUBLIC -> public [3:1]
    |--LITERAL_CLASS -> class [3:8]
    |--IDENT -> InputAntlr4AstRegressionPatternMatchingInSwitch [3:14]
    `--OBJBLOCK -> OBJBLOCK [3:62]
        |--LCURLY -> { [3:62]
        |--METHOD_DEF -> METHOD_DEF [4:5]
        |   |--MODIFIERS -> MODIFIERS [4:5]
        |   |   |--LITERAL_PUBLIC -> public [4:5]
        |   |   `--LITERAL_STATIC -> static [4:12]
        |   |--TYPE -> TYPE [4:19]
        |   |   `--LITERAL_VOID -> void [4:19]
        |   |--IDENT -> main [4:24]
        |   |--LPAREN -> ( [4:28]
        |   |--PARAMETERS -> PARAMETERS [4:29]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:29]
        |   |       |--MODIFIERS -> MODIFIERS [4:29]
        |   |       |--TYPE -> TYPE [4:29]
        |   |       |   |--IDENT -> String [4:29]
        |   |       |   `--ARRAY_DECLARATOR -> [ [4:35]
        |   |       |       `--RBRACK -> ] [4:36]
        |   |       `--IDENT -> args [4:38]
        |   |--RPAREN -> ) [4:42]
        |   `--SLIST -> { [4:44]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [5:9]
        |       |   |--MODIFIERS -> MODIFIERS [5:9]
        |       |   |--TYPE -> TYPE [5:9]
        |       |   |   `--IDENT -> Object [5:9]
        |       |   |--IDENT -> value [5:16]
        |       |   `--ASSIGN -> = [5:22]
        |       |       `--EXPR -> EXPR [5:24]
        |       |           `--NUM_INT -> 42 [5:24]
        |       |--SEMI -> ; [5:26]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [6:9]
        |       |   |--MODIFIERS -> MODIFIERS [6:9]
        |       |   |--TYPE -> TYPE [6:9]
        |       |   |   `--IDENT -> String [6:9]
        |       |   |--IDENT -> result [6:16]
        |       |   `--ASSIGN -> = [6:23]
        |       |       `--EXPR -> EXPR [6:25]
        |       |           `--LITERAL_SWITCH -> switch [6:25]
        |       |               |--LPAREN -> ( [6:32]
        |       |               |--EXPR -> EXPR [6:33]
        |       |               |   `--IDENT -> value [6:33]
        |       |               |--RPAREN -> ) [6:38]
        |       |               |--LCURLY -> { [6:40]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [7:13]
        |       |               |   |--LITERAL_CASE -> case [7:13]
        |       |               |   |   `--EXPR -> EXPR [7:18]
        |       |               |   |       `--LITERAL_NULL -> null [7:18]
        |       |               |   |--LAMBDA -> -> [7:23]
        |       |               |   |--EXPR -> EXPR [7:26]
        |       |               |   |   `--STRING_LITERAL -> "It's null..." [7:26]
        |       |               |   `--SEMI -> ; [7:40]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [8:13]
        |       |               |   |--LITERAL_CASE -> case [8:13]
        |       |               |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [8:18]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [8:18]
        |       |               |   |       |--TYPE -> TYPE [8:18]
        |       |               |   |       |   `--IDENT -> String [8:18]
        |       |               |   |       `--IDENT -> s [8:25]
        |       |               |   |--LAMBDA -> -> [8:27]
        |       |               |   |--EXPR -> EXPR [8:48]
        |       |               |   |   `--PLUS -> + [8:48]
        |       |               |   |       |--STRING_LITERAL -> "It's a string: " [8:30]
        |       |               |   |       `--IDENT -> s [8:50]
        |       |               |   `--SEMI -> ; [8:51]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [9:13]
        |       |               |   |--LITERAL_CASE -> case [9:13]
        |       |               |   |   `--PATTERN_DEF -> PATTERN_DEF [9:28]
        |       |               |   |       `--LITERAL_WHEN -> when [9:28]
        |       |               |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:18]
        |       |               |   |           |   |--MODIFIERS -> MODIFIERS [9:18]
        |       |               |   |           |   |--TYPE -> TYPE [9:18]
        |       |               |   |           |   |   `--IDENT -> Integer [9:18]
        |       |               |   |           |   `--IDENT -> i [9:26]
        |       |               |   |           `--EXPR -> EXPR [9:35]
        |       |               |   |               `--GT -> > [9:35]
        |       |               |   |                   |--IDENT -> i [9:33]
        |       |               |   |                   `--NUM_INT -> 50 [9:37]
        |       |               |   |--LAMBDA -> -> [9:40]
        |       |               |   |--EXPR -> EXPR [9:63]
        |       |               |   |   `--PLUS -> + [9:63]
        |       |               |   |       |--STRING_LITERAL -> "It's an integer: " [9:43]
        |       |               |   |       `--METHOD_CALL -> ( [9:75]
        |       |               |   |           |--DOT -> . [9:66]
        |       |               |   |           |   |--IDENT -> i [9:65]
        |       |               |   |           |   `--IDENT -> toString [9:67]
        |       |               |   |           |--ELIST -> ELIST [9:76]
        |       |               |   |           `--RPAREN -> ) [9:76]
        |       |               |   `--SEMI -> ; [9:77]
        |       |               |--SWITCH_RULE -> SWITCH_RULE [10:13]
        |       |               |   |--LITERAL_CASE -> case [10:13]
        |       |               |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [10:18]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [10:18]
        |       |               |   |       |--TYPE -> TYPE [10:18]
        |       |               |   |       |   `--IDENT -> Object [10:18]
        |       |               |   |       `--IDENT -> v [10:25]
        |       |               |   |--LAMBDA -> -> [10:27]
        |       |               |   |--EXPR -> EXPR [10:54]
        |       |               |   |   `--PLUS -> + [10:54]
        |       |               |   |       |--STRING_LITERAL -> "It's something else: " [10:30]
        |       |               |   |       `--METHOD_CALL -> ( [10:66]
        |       |               |   |           |--DOT -> . [10:57]
        |       |               |   |           |   |--IDENT -> v [10:56]
        |       |               |   |           |   `--IDENT -> toString [10:58]
        |       |               |   |           |--ELIST -> ELIST [10:67]
        |       |               |   |           `--RPAREN -> ) [10:67]
        |       |               |   `--SEMI -> ; [10:68]
        |       |               `--RCURLY -> } [11:9]
        |       |--SEMI -> ; [11:10]
        |       |--EXPR -> EXPR [12:27]
        |       |   `--METHOD_CALL -> ( [12:27]
        |       |       |--DOT -> . [12:19]
        |       |       |   |--DOT -> . [12:15]
        |       |       |   |   |--IDENT -> System [12:9]
        |       |       |   |   `--IDENT -> out [12:16]
        |       |       |   `--IDENT -> println [12:20]
        |       |       |--ELIST -> ELIST [12:28]
        |       |       |   `--EXPR -> EXPR [12:28]
        |       |       |       `--IDENT -> result [12:28]
        |       |       `--RPAREN -> ) [12:34]
        |       |--SEMI -> ; [12:35]
        |       `--RCURLY -> } [13:5]
        |--RECORD_DEF -> RECORD_DEF [15:5]
        |   |--MODIFIERS -> MODIFIERS [15:5]
        |   |--LITERAL_RECORD -> record [15:5]
        |   |--IDENT -> Point [15:12]
        |   |--LPAREN -> ( [15:17]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [15:18]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [15:18]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [15:18]
        |   |   |   |--TYPE -> TYPE [15:18]
        |   |   |   |   `--LITERAL_INT -> int [15:18]
        |   |   |   `--IDENT -> i [15:22]
        |   |   |--COMMA -> , [15:23]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [15:25]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [15:25]
        |   |       |--TYPE -> TYPE [15:25]
        |   |       |   `--LITERAL_INT -> int [15:25]
        |   |       `--IDENT -> j [15:29]
        |   |--RPAREN -> ) [15:30]
        |   `--OBJBLOCK -> OBJBLOCK [15:32]
        |       |--LCURLY -> { [15:32]
        |       `--RCURLY -> } [15:33]
        |--ENUM_DEF -> ENUM_DEF [16:5]
        |   |--MODIFIERS -> MODIFIERS [16:5]
        |   |--ENUM -> enum [16:5]
        |   |--IDENT -> Color [16:10]
        |   `--OBJBLOCK -> OBJBLOCK [16:16]
        |       |--LCURLY -> { [16:16]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [16:18]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [16:18]
        |       |   `--IDENT -> RED [16:18]
        |       |--COMMA -> , [16:21]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [16:23]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [16:23]
        |       |   `--IDENT -> GREEN [16:23]
        |       |--COMMA -> , [16:28]
        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [16:30]
        |       |   |--ANNOTATIONS -> ANNOTATIONS [16:30]
        |       |   `--IDENT -> BLUE [16:30]
        |       `--RCURLY -> } [16:35]
        |--METHOD_DEF -> METHOD_DEF [17:5]
        |   |--MODIFIERS -> MODIFIERS [17:5]
        |   |   `--LITERAL_STATIC -> static [17:5]
        |   |--TYPE -> TYPE [17:12]
        |   |   `--LITERAL_VOID -> void [17:12]
        |   |--IDENT -> typeTester [17:17]
        |   |--LPAREN -> ( [17:27]
        |   |--PARAMETERS -> PARAMETERS [17:28]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:28]
        |   |       |--MODIFIERS -> MODIFIERS [17:28]
        |   |       |--TYPE -> TYPE [17:28]
        |   |       |   `--IDENT -> Object [17:28]
        |   |       `--IDENT -> o [17:35]
        |   |--RPAREN -> ) [17:36]
        |   `--SLIST -> { [17:38]
        |       |--LITERAL_SWITCH -> switch [18:9]
        |       |   |--LPAREN -> ( [18:16]
        |       |   |--EXPR -> EXPR [18:17]
        |       |   |   `--IDENT -> o [18:17]
        |       |   |--RPAREN -> ) [18:18]
        |       |   |--LCURLY -> { [18:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [19:13]
        |       |   |   |--LITERAL_CASE -> case [19:13]
        |       |   |   |   `--EXPR -> EXPR [19:18]
        |       |   |   |       `--LITERAL_NULL -> null [19:18]
        |       |   |   |--LAMBDA -> -> [19:27]
        |       |   |   |--EXPR -> EXPR [19:48]
        |       |   |   |   `--METHOD_CALL -> ( [19:48]
        |       |   |   |       |--DOT -> . [19:40]
        |       |   |   |       |   |--DOT -> . [19:36]
        |       |   |   |       |   |   |--IDENT -> System [19:30]
        |       |   |   |       |   |   `--IDENT -> out [19:37]
        |       |   |   |       |   `--IDENT -> println [19:41]
        |       |   |   |       |--ELIST -> ELIST [19:49]
        |       |   |   |       |   `--EXPR -> EXPR [19:49]
        |       |   |   |       |       `--STRING_LITERAL -> "null" [19:49]
        |       |   |   |       `--RPAREN -> ) [19:55]
        |       |   |   `--SEMI -> ; [19:56]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [20:13]
        |       |   |   |--LITERAL_CASE -> case [20:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [20:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [20:18]
        |       |   |   |       |--TYPE -> TYPE [20:18]
        |       |   |   |       |   `--IDENT -> String [20:18]
        |       |   |   |       `--IDENT -> s [20:25]
        |       |   |   |--LAMBDA -> -> [20:27]
        |       |   |   |--EXPR -> EXPR [20:48]
        |       |   |   |   `--METHOD_CALL -> ( [20:48]
        |       |   |   |       |--DOT -> . [20:40]
        |       |   |   |       |   |--DOT -> . [20:36]
        |       |   |   |       |   |   |--IDENT -> System [20:30]
        |       |   |   |       |   |   `--IDENT -> out [20:37]
        |       |   |   |       |   `--IDENT -> println [20:41]
        |       |   |   |       |--ELIST -> ELIST [20:49]
        |       |   |   |       |   `--EXPR -> EXPR [20:49]
        |       |   |   |       |       `--STRING_LITERAL -> "String" [20:49]
        |       |   |   |       `--RPAREN -> ) [20:57]
        |       |   |   `--SEMI -> ; [20:58]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [21:13]
        |       |   |   |--LITERAL_CASE -> case [21:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [21:18]
        |       |   |   |       |--TYPE -> TYPE [21:18]
        |       |   |   |       |   `--IDENT -> Color [21:18]
        |       |   |   |       `--IDENT -> c [21:24]
        |       |   |   |--LAMBDA -> -> [21:27]
        |       |   |   |--EXPR -> EXPR [21:48]
        |       |   |   |   `--METHOD_CALL -> ( [21:48]
        |       |   |   |       |--DOT -> . [21:40]
        |       |   |   |       |   |--DOT -> . [21:36]
        |       |   |   |       |   |   |--IDENT -> System [21:30]
        |       |   |   |       |   |   `--IDENT -> out [21:37]
        |       |   |   |       |   `--IDENT -> println [21:41]
        |       |   |   |       |--ELIST -> ELIST [21:87]
        |       |   |   |       |   `--EXPR -> EXPR [21:87]
        |       |   |   |       |       `--PLUS -> + [21:87]
        |       |   |   |       |           |--PLUS -> + [21:63]
        |       |   |   |       |           |   |--STRING_LITERAL -> "Color with " [21:49]
        |       |   |   |       |           |   `--DOT -> . [21:79]
        |       |   |   |       |           |       |--METHOD_CALL -> ( [21:77]
        |       |   |   |       |           |       |   |--DOT -> . [21:70]
        |       |   |   |       |           |       |   |   |--IDENT -> Color [21:65]
        |       |   |   |       |           |       |   |   `--IDENT -> values [21:71]
        |       |   |   |       |           |       |   |--ELIST -> ELIST [21:78]
        |       |   |   |       |           |       |   `--RPAREN -> ) [21:78]
        |       |   |   |       |           |       `--IDENT -> length [21:80]
        |       |   |   |       |           `--STRING_LITERAL -> " values" [21:89]
        |       |   |   |       `--RPAREN -> ) [21:98]
        |       |   |   `--SEMI -> ; [21:99]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [22:13]
        |       |   |   |--LITERAL_CASE -> case [22:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [22:18]
        |       |   |   |       |--TYPE -> TYPE [22:18]
        |       |   |   |       |   `--IDENT -> Point [22:18]
        |       |   |   |       `--IDENT -> p [22:24]
        |       |   |   |--LAMBDA -> -> [22:27]
        |       |   |   |--EXPR -> EXPR [22:48]
        |       |   |   |   `--METHOD_CALL -> ( [22:48]
        |       |   |   |       |--DOT -> . [22:40]
        |       |   |   |       |   |--DOT -> . [22:36]
        |       |   |   |       |   |   |--IDENT -> System [22:30]
        |       |   |   |       |   |   `--IDENT -> out [22:37]
        |       |   |   |       |   `--IDENT -> println [22:41]
        |       |   |   |       |--ELIST -> ELIST [22:66]
        |       |   |   |       |   `--EXPR -> EXPR [22:66]
        |       |   |   |       |       `--PLUS -> + [22:66]
        |       |   |   |       |           |--STRING_LITERAL -> "Record class: " [22:49]
        |       |   |   |       |           `--METHOD_CALL -> ( [22:78]
        |       |   |   |       |               |--DOT -> . [22:69]
        |       |   |   |       |               |   |--IDENT -> p [22:68]
        |       |   |   |       |               |   `--IDENT -> toString [22:70]
        |       |   |   |       |               |--ELIST -> ELIST [22:79]
        |       |   |   |       |               `--RPAREN -> ) [22:79]
        |       |   |   |       `--RPAREN -> ) [22:80]
        |       |   |   `--SEMI -> ; [22:81]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [23:13]
        |       |   |   |--LITERAL_CASE -> case [23:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [23:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [23:18]
        |       |   |   |       |--TYPE -> TYPE [23:18]
        |       |   |   |       |   |--LITERAL_INT -> int [23:18]
        |       |   |   |       |   `--ARRAY_DECLARATOR -> [ [23:21]
        |       |   |   |       |       `--RBRACK -> ] [23:22]
        |       |   |   |       `--IDENT -> ia [23:24]
        |       |   |   |--LAMBDA -> -> [23:27]
        |       |   |   |--EXPR -> EXPR [23:48]
        |       |   |   |   `--METHOD_CALL -> ( [23:48]
        |       |   |   |       |--DOT -> . [23:40]
        |       |   |   |       |   |--DOT -> . [23:36]
        |       |   |   |       |   |   |--IDENT -> System [23:30]
        |       |   |   |       |   |   `--IDENT -> out [23:37]
        |       |   |   |       |   `--IDENT -> println [23:41]
        |       |   |   |       |--ELIST -> ELIST [23:75]
        |       |   |   |       |   `--EXPR -> EXPR [23:75]
        |       |   |   |       |       `--PLUS -> + [23:75]
        |       |   |   |       |           |--STRING_LITERAL -> "Array of ints of length" [23:49]
        |       |   |   |       |           `--DOT -> . [23:79]
        |       |   |   |       |               |--IDENT -> ia [23:77]
        |       |   |   |       |               `--IDENT -> length [23:80]
        |       |   |   |       `--RPAREN -> ) [23:86]
        |       |   |   `--SEMI -> ; [23:87]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [24:13]
        |       |   |   |--LITERAL_DEFAULT -> default [24:13]
        |       |   |   |--LAMBDA -> -> [24:27]
        |       |   |   |--EXPR -> EXPR [24:48]
        |       |   |   |   `--METHOD_CALL -> ( [24:48]
        |       |   |   |       |--DOT -> . [24:40]
        |       |   |   |       |   |--DOT -> . [24:36]
        |       |   |   |       |   |   |--IDENT -> System [24:30]
        |       |   |   |       |   |   `--IDENT -> out [24:37]
        |       |   |   |       |   `--IDENT -> println [24:41]
        |       |   |   |       |--ELIST -> ELIST [24:49]
        |       |   |   |       |   `--EXPR -> EXPR [24:49]
        |       |   |   |       |       `--STRING_LITERAL -> "Something else" [24:49]
        |       |   |   |       `--RPAREN -> ) [24:65]
        |       |   |   `--SEMI -> ; [24:66]
        |       |   `--RCURLY -> } [25:9]
        |       `--RCURLY -> } [26:5]
        |--METHOD_DEF -> METHOD_DEF [27:5]
        |   |--MODIFIERS -> MODIFIERS [27:5]
        |   |   `--LITERAL_STATIC -> static [27:5]
        |   |--TYPE -> TYPE [27:12]
        |   |   `--LITERAL_VOID -> void [27:12]
        |   |--IDENT -> error [27:17]
        |   |--LPAREN -> ( [27:22]
        |   |--PARAMETERS -> PARAMETERS [27:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [27:23]
        |   |       |--MODIFIERS -> MODIFIERS [27:23]
        |   |       |--TYPE -> TYPE [27:23]
        |   |       |   `--IDENT -> Object [27:23]
        |   |       `--IDENT -> o [27:30]
        |   |--RPAREN -> ) [27:31]
        |   `--SLIST -> { [27:33]
        |       |--LITERAL_SWITCH -> switch [28:9]
        |       |   |--LPAREN -> ( [28:15]
        |       |   |--EXPR -> EXPR [28:16]
        |       |   |   `--IDENT -> o [28:16]
        |       |   |--RPAREN -> ) [28:17]
        |       |   |--LCURLY -> { [28:19]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [29:13]
        |       |   |   |--LITERAL_CASE -> case [29:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [29:18]
        |       |   |   |       |--TYPE -> TYPE [29:18]
        |       |   |   |       |   `--IDENT -> String [29:18]
        |       |   |   |       `--IDENT -> s [29:25]
        |       |   |   |--LAMBDA -> -> [29:27]
        |       |   |   |--EXPR -> EXPR [30:35]
        |       |   |   |   `--METHOD_CALL -> ( [30:35]
        |       |   |   |       |--DOT -> . [30:27]
        |       |   |   |       |   |--DOT -> . [30:23]
        |       |   |   |       |   |   |--IDENT -> System [30:17]
        |       |   |   |       |   |   `--IDENT -> out [30:24]
        |       |   |   |       |   `--IDENT -> println [30:28]
        |       |   |   |       |--ELIST -> ELIST [30:49]
        |       |   |   |       |   `--EXPR -> EXPR [30:49]
        |       |   |   |       |       `--PLUS -> + [30:49]
        |       |   |   |       |           |--STRING_LITERAL -> "A string: " [30:36]
        |       |   |   |       |           `--IDENT -> s [30:51]
        |       |   |   |       `--RPAREN -> ) [30:52]
        |       |   |   `--SEMI -> ; [30:53]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [31:13]
        |       |   |   |--LITERAL_CASE -> case [31:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [31:18]
        |       |   |   |       |--TYPE -> TYPE [31:18]
        |       |   |   |       |   `--IDENT -> CharSequence [31:18]
        |       |   |   |       `--IDENT -> cs [31:31]
        |       |   |   |--LAMBDA -> -> [31:34]
        |       |   |   |--EXPR -> EXPR [32:35]
        |       |   |   |   `--METHOD_CALL -> ( [32:35]
        |       |   |   |       |--DOT -> . [32:27]
        |       |   |   |       |   |--DOT -> . [32:23]
        |       |   |   |       |   |   |--IDENT -> System [32:17]
        |       |   |   |       |   |   `--IDENT -> out [32:24]
        |       |   |   |       |   `--IDENT -> println [32:28]
        |       |   |   |       |--ELIST -> ELIST [32:60]
        |       |   |   |       |   `--EXPR -> EXPR [32:60]
        |       |   |   |       |       `--PLUS -> + [32:60]
        |       |   |   |       |           |--STRING_LITERAL -> "A sequence of length " [32:36]
        |       |   |   |       |           `--METHOD_CALL -> ( [32:71]
        |       |   |   |       |               |--DOT -> . [32:64]
        |       |   |   |       |               |   |--IDENT -> cs [32:62]
        |       |   |   |       |               |   `--IDENT -> length [32:65]
        |       |   |   |       |               |--ELIST -> ELIST [32:72]
        |       |   |   |       |               `--RPAREN -> ) [32:72]
        |       |   |   |       `--RPAREN -> ) [32:73]
        |       |   |   `--SEMI -> ; [32:74]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [33:13]
        |       |   |   |--LITERAL_DEFAULT -> default [33:13]
        |       |   |   |--LAMBDA -> -> [33:21]
        |       |   |   `--SLIST -> { [33:24]
        |       |   |       |--LITERAL_BREAK -> break [34:17]
        |       |   |       |   `--SEMI -> ; [34:22]
        |       |   |       `--RCURLY -> } [35:13]
        |       |   `--RCURLY -> } [36:9]
        |       `--RCURLY -> } [37:5]
        |--METHOD_DEF -> METHOD_DEF [38:5]
        |   |--MODIFIERS -> MODIFIERS [38:5]
        |   |   `--LITERAL_STATIC -> static [38:5]
        |   |--TYPE -> TYPE [38:12]
        |   |   `--LITERAL_VOID -> void [38:12]
        |   |--IDENT -> m1 [38:17]
        |   |--LPAREN -> ( [38:19]
        |   |--PARAMETERS -> PARAMETERS [38:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:20]
        |   |       |--MODIFIERS -> MODIFIERS [38:20]
        |   |       |--TYPE -> TYPE [38:20]
        |   |       |   `--IDENT -> Object [38:20]
        |   |       `--IDENT -> o [38:27]
        |   |--RPAREN -> ) [38:28]
        |   `--SLIST -> { [38:30]
        |       |--LITERAL_SWITCH -> switch [39:9]
        |       |   |--LPAREN -> ( [39:16]
        |       |   |--EXPR -> EXPR [39:17]
        |       |   |   `--IDENT -> o [39:17]
        |       |   |--RPAREN -> ) [39:18]
        |       |   |--LCURLY -> { [39:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [40:13]
        |       |   |   |--LITERAL_CASE -> case [40:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [40:27]
        |       |   |   |   |   `--LITERAL_WHEN -> when [40:27]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [40:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [40:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [40:18]
        |       |   |   |   |       |   |   `--IDENT -> String [40:18]
        |       |   |   |   |       |   `--IDENT -> s [40:25]
        |       |   |   |   |       `--EXPR -> EXPR [40:43]
        |       |   |   |   |           `--GT -> > [40:43]
        |       |   |   |   |               |--METHOD_CALL -> ( [40:40]
        |       |   |   |   |               |   |--DOT -> . [40:33]
        |       |   |   |   |               |   |   |--IDENT -> s [40:32]
        |       |   |   |   |               |   |   `--IDENT -> length [40:34]
        |       |   |   |   |               |   |--ELIST -> ELIST [40:41]
        |       |   |   |   |               |   `--RPAREN -> ) [40:41]
        |       |   |   |   |               `--NUM_INT -> 4 [40:45]
        |       |   |   |   `--COLON -> : [40:46]
        |       |   |   `--SLIST -> SLIST [41:35]
        |       |   |       |--EXPR -> EXPR [41:35]
        |       |   |       |   `--METHOD_CALL -> ( [41:35]
        |       |   |       |       |--DOT -> . [41:27]
        |       |   |       |       |   |--DOT -> . [41:23]
        |       |   |       |       |   |   |--IDENT -> System [41:17]
        |       |   |       |       |   |   `--IDENT -> out [41:24]
        |       |   |       |       |   `--IDENT -> println [41:28]
        |       |   |       |       |--ELIST -> ELIST [41:36]
        |       |   |       |       |   `--EXPR -> EXPR [41:36]
        |       |   |       |       |       `--IDENT -> s [41:36]
        |       |   |       |       `--RPAREN -> ) [41:37]
        |       |   |       |--SEMI -> ; [41:38]
        |       |   |       `--LITERAL_BREAK -> break [42:17]
        |       |   |           `--SEMI -> ; [42:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [43:13]
        |       |   |   |--LITERAL_CASE -> case [43:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [43:28]
        |       |   |   |   |   `--LITERAL_WHEN -> when [43:28]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [43:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [43:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [43:18]
        |       |   |   |   |       |   `--IDENT -> i [43:26]
        |       |   |   |   |       `--EXPR -> EXPR [43:35]
        |       |   |   |   |           `--GT -> > [43:35]
        |       |   |   |   |               |--IDENT -> i [43:33]
        |       |   |   |   |               `--NUM_INT -> 40 [43:37]
        |       |   |   |   `--COLON -> : [43:39]
        |       |   |   `--SLIST -> SLIST [44:35]
        |       |   |       |--EXPR -> EXPR [44:35]
        |       |   |       |   `--METHOD_CALL -> ( [44:35]
        |       |   |       |       |--DOT -> . [44:27]
        |       |   |       |       |   |--DOT -> . [44:23]
        |       |   |       |       |   |   |--IDENT -> System [44:17]
        |       |   |       |       |   |   `--IDENT -> out [44:24]
        |       |   |       |       |   `--IDENT -> println [44:28]
        |       |   |       |       |--ELIST -> ELIST [44:36]
        |       |   |       |       |   `--EXPR -> EXPR [44:36]
        |       |   |       |       |       `--STRING_LITERAL -> "Integer" [44:36]
        |       |   |       |       `--RPAREN -> ) [44:45]
        |       |   |       |--SEMI -> ; [44:46]
        |       |   |       `--LITERAL_BREAK -> break [45:17]
        |       |   |           `--SEMI -> ; [45:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [46:13]
        |       |   |   |--LITERAL_DEFAULT -> default [46:13]
        |       |   |   |   `--COLON -> : [46:20]
        |       |   |   `--SLIST -> SLIST [47:17]
        |       |   |       `--LITERAL_BREAK -> break [47:17]
        |       |   |           `--SEMI -> ; [47:22]
        |       |   `--RCURLY -> } [48:9]
        |       `--RCURLY -> } [49:5]
        |--METHOD_DEF -> METHOD_DEF [50:5]
        |   |--MODIFIERS -> MODIFIERS [50:5]
        |   |   `--LITERAL_STATIC -> static [50:5]
        |   |--TYPE -> TYPE [50:12]
        |   |   `--LITERAL_VOID -> void [50:12]
        |   |--IDENT -> m2 [50:17]
        |   |--LPAREN -> ( [50:19]
        |   |--PARAMETERS -> PARAMETERS [50:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [50:20]
        |   |       |--MODIFIERS -> MODIFIERS [50:20]
        |   |       |--TYPE -> TYPE [50:20]
        |   |       |   `--IDENT -> Object [50:20]
        |   |       `--IDENT -> o [50:27]
        |   |--RPAREN -> ) [50:28]
        |   `--SLIST -> { [50:30]
        |       |--LITERAL_SWITCH -> switch [51:9]
        |       |   |--LPAREN -> ( [51:16]
        |       |   |--EXPR -> EXPR [51:17]
        |       |   |   `--IDENT -> o [51:17]
        |       |   |--RPAREN -> ) [51:18]
        |       |   |--LCURLY -> { [51:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [52:13]
        |       |   |   |--LITERAL_CASE -> case [52:13]
        |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [52:27]
        |       |   |   |       `--LITERAL_WHEN -> when [52:27]
        |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:18]
        |       |   |   |           |   |--MODIFIERS -> MODIFIERS [52:18]
        |       |   |   |           |   |--TYPE -> TYPE [52:18]
        |       |   |   |           |   |   `--IDENT -> String [52:18]
        |       |   |   |           |   `--IDENT -> s [52:25]
        |       |   |   |           `--EXPR -> EXPR [52:43]
        |       |   |   |               `--GT -> > [52:43]
        |       |   |   |                   |--METHOD_CALL -> ( [52:40]
        |       |   |   |                   |   |--DOT -> . [52:33]
        |       |   |   |                   |   |   |--IDENT -> s [52:32]
        |       |   |   |                   |   |   `--IDENT -> length [52:34]
        |       |   |   |                   |   |--ELIST -> ELIST [52:41]
        |       |   |   |                   |   `--RPAREN -> ) [52:41]
        |       |   |   |                   `--NUM_INT -> 4 [52:45]
        |       |   |   |--LAMBDA -> -> [52:47]
        |       |   |   |--EXPR -> EXPR [52:68]
        |       |   |   |   `--METHOD_CALL -> ( [52:68]
        |       |   |   |       |--DOT -> . [52:60]
        |       |   |   |       |   |--DOT -> . [52:56]
        |       |   |   |       |   |   |--IDENT -> System [52:50]
        |       |   |   |       |   |   `--IDENT -> out [52:57]
        |       |   |   |       |   `--IDENT -> println [52:61]
        |       |   |   |       |--ELIST -> ELIST [52:69]
        |       |   |   |       |   `--EXPR -> EXPR [52:69]
        |       |   |   |       |       `--IDENT -> s [52:69]
        |       |   |   |       `--RPAREN -> ) [52:70]
        |       |   |   `--SEMI -> ; [52:71]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [53:13]
        |       |   |   |--LITERAL_CASE -> case [53:13]
        |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [53:28]
        |       |   |   |       `--LITERAL_WHEN -> when [53:28]
        |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [53:18]
        |       |   |   |           |   |--MODIFIERS -> MODIFIERS [53:18]
        |       |   |   |           |   |--TYPE -> TYPE [53:18]
        |       |   |   |           |   |   `--IDENT -> Integer [53:18]
        |       |   |   |           |   `--IDENT -> i [53:26]
        |       |   |   |           `--EXPR -> EXPR [53:35]
        |       |   |   |               `--GT -> > [53:35]
        |       |   |   |                   |--IDENT -> i [53:33]
        |       |   |   |                   `--NUM_INT -> 40 [53:37]
        |       |   |   |--LAMBDA -> -> [53:40]
        |       |   |   |--EXPR -> EXPR [53:61]
        |       |   |   |   `--METHOD_CALL -> ( [53:61]
        |       |   |   |       |--DOT -> . [53:53]
        |       |   |   |       |   |--DOT -> . [53:49]
        |       |   |   |       |   |   |--IDENT -> System [53:43]
        |       |   |   |       |   |   `--IDENT -> out [53:50]
        |       |   |   |       |   `--IDENT -> println [53:54]
        |       |   |   |       |--ELIST -> ELIST [53:62]
        |       |   |   |       |   `--EXPR -> EXPR [53:62]
        |       |   |   |       |       `--STRING_LITERAL -> "Integer" [53:62]
        |       |   |   |       `--RPAREN -> ) [53:71]
        |       |   |   `--SEMI -> ; [53:72]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [54:13]
        |       |   |   |--LITERAL_DEFAULT -> default [54:13]
        |       |   |   |--LAMBDA -> -> [54:21]
        |       |   |   `--SLIST -> { [54:24]
        |       |   |       `--RCURLY -> } [55:13]
        |       |   `--RCURLY -> } [56:9]
        |       `--RCURLY -> } [57:5]
        |--METHOD_DEF -> METHOD_DEF [58:5]
        |   |--MODIFIERS -> MODIFIERS [58:5]
        |   |   `--LITERAL_STATIC -> static [58:5]
        |   |--TYPE -> TYPE [58:12]
        |   |   `--LITERAL_VOID -> void [58:12]
        |   |--IDENT -> test1 [58:17]
        |   |--LPAREN -> ( [58:22]
        |   |--PARAMETERS -> PARAMETERS [58:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:23]
        |   |       |--MODIFIERS -> MODIFIERS [58:23]
        |   |       |--TYPE -> TYPE [58:23]
        |   |       |   `--IDENT -> Object [58:23]
        |   |       `--IDENT -> o [58:30]
        |   |--RPAREN -> ) [58:31]
        |   `--SLIST -> { [58:33]
        |       |--LITERAL_SWITCH -> switch [59:9]
        |       |   |--LPAREN -> ( [59:16]
        |       |   |--EXPR -> EXPR [59:17]
        |       |   |   `--IDENT -> o [59:17]
        |       |   |--RPAREN -> ) [59:18]
        |       |   |--LCURLY -> { [59:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [60:13]
        |       |   |   |--LITERAL_CASE -> case [60:13]
        |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [60:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [60:18]
        |       |   |   |       |--TYPE -> TYPE [60:18]
        |       |   |   |       |   `--IDENT -> Character [60:18]
        |       |   |   |       `--IDENT -> c [60:28]
        |       |   |   |--LAMBDA -> -> [60:30]
        |       |   |   `--SLIST -> { [60:33]
        |       |   |       |--LITERAL_IF -> if [61:17]
        |       |   |       |   |--LPAREN -> ( [61:20]
        |       |   |       |   |--EXPR -> EXPR [61:23]
        |       |   |       |   |   `--EQUAL -> == [61:23]
        |       |   |       |   |       |--IDENT -> c [61:21]
        |       |   |       |   |       `--NUM_INT -> 7 [61:26]
        |       |   |       |   |--RPAREN -> ) [61:27]
        |       |   |       |   `--SLIST -> { [61:29]
        |       |   |       |       |--EXPR -> EXPR [62:39]
        |       |   |       |       |   `--METHOD_CALL -> ( [62:39]
        |       |   |       |       |       |--DOT -> . [62:31]
        |       |   |       |       |       |   |--DOT -> . [62:27]
        |       |   |       |       |       |   |   |--IDENT -> System [62:21]
        |       |   |       |       |       |   |   `--IDENT -> out [62:28]
        |       |   |       |       |       |   `--IDENT -> println [62:32]
        |       |   |       |       |       |--ELIST -> ELIST [62:40]
        |       |   |       |       |       |   `--EXPR -> EXPR [62:40]
        |       |   |       |       |       |       `--STRING_LITERAL -> "Ding!" [62:40]
        |       |   |       |       |       `--RPAREN -> ) [62:47]
        |       |   |       |       |--SEMI -> ; [62:48]
        |       |   |       |       `--RCURLY -> } [63:17]
        |       |   |       |--EXPR -> EXPR [64:35]
        |       |   |       |   `--METHOD_CALL -> ( [64:35]
        |       |   |       |       |--DOT -> . [64:27]
        |       |   |       |       |   |--DOT -> . [64:23]
        |       |   |       |       |   |   |--IDENT -> System [64:17]
        |       |   |       |       |   |   `--IDENT -> out [64:24]
        |       |   |       |       |   `--IDENT -> println [64:28]
        |       |   |       |       |--ELIST -> ELIST [64:36]
        |       |   |       |       |   `--EXPR -> EXPR [64:36]
        |       |   |       |       |       `--STRING_LITERAL -> "Character" [64:36]
        |       |   |       |       `--RPAREN -> ) [64:47]
        |       |   |       |--SEMI -> ; [64:48]
        |       |   |       `--RCURLY -> } [65:13]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [66:13]
        |       |   |   |--LITERAL_CASE -> case [66:13]
        |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [66:28]
        |       |   |   |       `--LITERAL_WHEN -> when [66:28]
        |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [66:18]
        |       |   |   |           |   |--MODIFIERS -> MODIFIERS [66:18]
        |       |   |   |           |   |--TYPE -> TYPE [66:18]
        |       |   |   |           |   |   `--IDENT -> Integer [66:18]
        |       |   |   |           |   `--IDENT -> i [66:26]
        |       |   |   |           `--EXPR -> EXPR [66:33]
        |       |   |   |               |--LPAREN -> ( [66:33]
        |       |   |   |               |--GT -> > [66:36]
        |       |   |   |               |   |--IDENT -> i [66:34]
        |       |   |   |               |   `--NUM_INT -> 2 [66:38]
        |       |   |   |               `--RPAREN -> ) [66:39]
        |       |   |   |--LAMBDA -> -> [66:41]
        |       |   |   `--LITERAL_THROW -> throw [67:17]
        |       |   |       |--EXPR -> EXPR [67:23]
        |       |   |       |   `--LITERAL_NEW -> new [67:23]
        |       |   |       |       |--IDENT -> IllegalStateException [67:27]
        |       |   |       |       |--LPAREN -> ( [67:48]
        |       |   |       |       |--ELIST -> ELIST [67:86]
        |       |   |       |       |   `--EXPR -> EXPR [67:86]
        |       |   |       |       |       `--PLUS -> + [67:86]
        |       |   |       |       |           |--STRING_LITERAL -> "Invalid Integer argument of value " [67:49]
        |       |   |       |       |           `--IDENT -> i [67:88]
        |       |   |       |       `--RPAREN -> ) [67:89]
        |       |   |       `--SEMI -> ; [67:90]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [68:13]
        |       |   |   |--LITERAL_DEFAULT -> default [68:13]
        |       |   |   |--LAMBDA -> -> [68:21]
        |       |   |   `--SLIST -> { [68:24]
        |       |   |       |--LITERAL_BREAK -> break [69:17]
        |       |   |       |   `--SEMI -> ; [69:22]
        |       |   |       `--RCURLY -> } [70:13]
        |       |   `--RCURLY -> } [71:9]
        |       `--RCURLY -> } [72:5]
        |--METHOD_DEF -> METHOD_DEF [73:5]
        |   |--MODIFIERS -> MODIFIERS [73:5]
        |   |   `--LITERAL_STATIC -> static [73:5]
        |   |--TYPE -> TYPE [73:12]
        |   |   `--LITERAL_VOID -> void [73:12]
        |   |--IDENT -> test2 [73:17]
        |   |--LPAREN -> ( [73:22]
        |   |--PARAMETERS -> PARAMETERS [73:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [73:23]
        |   |       |--MODIFIERS -> MODIFIERS [73:23]
        |   |       |--TYPE -> TYPE [73:23]
        |   |       |   `--IDENT -> Object [73:23]
        |   |       `--IDENT -> o [73:30]
        |   |--RPAREN -> ) [73:31]
        |   `--SLIST -> { [73:33]
        |       |--LITERAL_SWITCH -> switch [74:9]
        |       |   |--LPAREN -> ( [74:16]
        |       |   |--EXPR -> EXPR [74:17]
        |       |   |   `--IDENT -> o [74:17]
        |       |   |--RPAREN -> ) [74:18]
        |       |   |--LCURLY -> { [74:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [75:13]
        |       |   |   |--LITERAL_CASE -> case [75:13]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [75:18]
        |       |   |   |   |   |--TYPE -> TYPE [75:18]
        |       |   |   |   |   |   `--IDENT -> Character [75:18]
        |       |   |   |   |   `--IDENT -> c [75:28]
        |       |   |   |   `--COLON -> : [75:29]
        |       |   |   `--SLIST -> SLIST [76:17]
        |       |   |       |--LITERAL_IF -> if [76:17]
        |       |   |       |   |--LPAREN -> ( [76:20]
        |       |   |       |   |--EXPR -> EXPR [76:35]
        |       |   |       |   |   `--EQUAL -> == [76:35]
        |       |   |       |   |       |--METHOD_CALL -> ( [76:32]
        |       |   |       |   |       |   |--DOT -> . [76:22]
        |       |   |       |   |       |   |   |--IDENT -> c [76:21]
        |       |   |       |   |       |   |   `--IDENT -> charValue [76:23]
        |       |   |       |   |       |   |--ELIST -> ELIST [76:33]
        |       |   |       |   |       |   `--RPAREN -> ) [76:33]
        |       |   |       |   |       `--NUM_INT -> 7 [76:38]
        |       |   |       |   |--RPAREN -> ) [76:39]
        |       |   |       |   `--SLIST -> { [76:41]
        |       |   |       |       |--EXPR -> EXPR [77:37]
        |       |   |       |       |   `--METHOD_CALL -> ( [77:37]
        |       |   |       |       |       |--DOT -> . [77:31]
        |       |   |       |       |       |   |--DOT -> . [77:27]
        |       |   |       |       |       |   |   |--IDENT -> System [77:21]
        |       |   |       |       |       |   |   `--IDENT -> out [77:28]
        |       |   |       |       |       |   `--IDENT -> print [77:32]
        |       |   |       |       |       |--ELIST -> ELIST [77:38]
        |       |   |       |       |       |   `--EXPR -> EXPR [77:38]
        |       |   |       |       |       |       `--STRING_LITERAL -> "Ding " [77:38]
        |       |   |       |       |       `--RPAREN -> ) [77:45]
        |       |   |       |       |--SEMI -> ; [77:46]
        |       |   |       |       `--RCURLY -> } [78:17]
        |       |   |       |--LITERAL_IF -> if [79:17]
        |       |   |       |   |--LPAREN -> ( [79:20]
        |       |   |       |   |--EXPR -> EXPR [79:35]
        |       |   |       |   |   `--EQUAL -> == [79:35]
        |       |   |       |   |       |--METHOD_CALL -> ( [79:32]
        |       |   |       |   |       |   |--DOT -> . [79:22]
        |       |   |       |   |       |   |   |--IDENT -> c [79:21]
        |       |   |       |   |       |   |   `--IDENT -> charValue [79:23]
        |       |   |       |   |       |   |--ELIST -> ELIST [79:33]
        |       |   |       |   |       |   `--RPAREN -> ) [79:33]
        |       |   |       |   |       `--NUM_INT -> 9 [79:38]
        |       |   |       |   |--RPAREN -> ) [79:39]
        |       |   |       |   `--SLIST -> { [79:41]
        |       |   |       |       |--EXPR -> EXPR [80:37]
        |       |   |       |       |   `--METHOD_CALL -> ( [80:37]
        |       |   |       |       |       |--DOT -> . [80:31]
        |       |   |       |       |       |   |--DOT -> . [80:27]
        |       |   |       |       |       |   |   |--IDENT -> System [80:21]
        |       |   |       |       |       |   |   `--IDENT -> out [80:28]
        |       |   |       |       |       |   `--IDENT -> print [80:32]
        |       |   |       |       |       |--ELIST -> ELIST [80:38]
        |       |   |       |       |       |   `--EXPR -> EXPR [80:38]
        |       |   |       |       |       |       `--STRING_LITERAL -> "Tab " [80:38]
        |       |   |       |       |       `--RPAREN -> ) [80:44]
        |       |   |       |       |--SEMI -> ; [80:45]
        |       |   |       |       `--RCURLY -> } [81:17]
        |       |   |       |--EXPR -> EXPR [82:35]
        |       |   |       |   `--METHOD_CALL -> ( [82:35]
        |       |   |       |       |--DOT -> . [82:27]
        |       |   |       |       |   |--DOT -> . [82:23]
        |       |   |       |       |   |   |--IDENT -> System [82:17]
        |       |   |       |       |   |   `--IDENT -> out [82:24]
        |       |   |       |       |   `--IDENT -> println [82:28]
        |       |   |       |       |--ELIST -> ELIST [82:36]
        |       |   |       |       |   `--EXPR -> EXPR [82:36]
        |       |   |       |       |       `--STRING_LITERAL -> "character" [82:36]
        |       |   |       |       `--RPAREN -> ) [82:47]
        |       |   |       `--SEMI -> ; [82:48]
        |       |   |--CASE_GROUP -> CASE_GROUP [83:13]
        |       |   |   |--LITERAL_DEFAULT -> default [83:13]
        |       |   |   |   `--COLON -> : [83:20]
        |       |   |   `--SLIST -> SLIST [84:35]
        |       |   |       |--EXPR -> EXPR [84:35]
        |       |   |       |   `--METHOD_CALL -> ( [84:35]
        |       |   |       |       |--DOT -> . [84:27]
        |       |   |       |       |   |--DOT -> . [84:23]
        |       |   |       |       |   |   |--IDENT -> System [84:17]
        |       |   |       |       |   |   `--IDENT -> out [84:24]
        |       |   |       |       |   `--IDENT -> println [84:28]
        |       |   |       |       |--ELIST -> ELIST [84:36]
        |       |   |       |       `--RPAREN -> ) [84:36]
        |       |   |       `--SEMI -> ; [84:37]
        |       |   `--RCURLY -> } [85:9]
        |       `--RCURLY -> } [86:5]
        |--METHOD_DEF -> METHOD_DEF [87:5]
        |   |--MODIFIERS -> MODIFIERS [87:5]
        |   |   `--LITERAL_STATIC -> static [87:5]
        |   |--TYPE -> TYPE [87:12]
        |   |   `--LITERAL_VOID -> void [87:12]
        |   |--IDENT -> test3 [87:17]
        |   |--LPAREN -> ( [87:22]
        |   |--PARAMETERS -> PARAMETERS [87:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [87:23]
        |   |       |--MODIFIERS -> MODIFIERS [87:23]
        |   |       |--TYPE -> TYPE [87:23]
        |   |       |   `--IDENT -> Object [87:23]
        |   |       `--IDENT -> o [87:30]
        |   |--RPAREN -> ) [87:31]
        |   `--SLIST -> { [87:33]
        |       |--LITERAL_SWITCH -> switch [88:9]
        |       |   |--LPAREN -> ( [88:15]
        |       |   |--EXPR -> EXPR [88:16]
        |       |   |   `--IDENT -> o [88:16]
        |       |   |--RPAREN -> ) [88:17]
        |       |   |--LCURLY -> { [88:19]
        |       |   |--CASE_GROUP -> CASE_GROUP [89:13]
        |       |   |   |--LITERAL_CASE -> case [89:13]
        |       |   |   |   |--EXPR -> EXPR [89:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [89:18]
        |       |   |   |   `--COLON -> : [89:22]
        |       |   |   |--LITERAL_DEFAULT -> default [89:24]
        |       |   |   |   `--COLON -> : [89:31]
        |       |   |   `--SLIST -> SLIST [90:35]
        |       |   |       |--EXPR -> EXPR [90:35]
        |       |   |       |   `--METHOD_CALL -> ( [90:35]
        |       |   |       |       |--DOT -> . [90:27]
        |       |   |       |       |   |--DOT -> . [90:23]
        |       |   |       |       |   |   |--IDENT -> System [90:17]
        |       |   |       |       |   |   `--IDENT -> out [90:24]
        |       |   |       |       |   `--IDENT -> println [90:28]
        |       |   |       |       |--ELIST -> ELIST [90:36]
        |       |   |       |       |   `--EXPR -> EXPR [90:36]
        |       |   |       |       |       `--STRING_LITERAL -> "String, including null" [90:36]
        |       |   |       |       `--RPAREN -> ) [90:60]
        |       |   |       |--SEMI -> ; [90:61]
        |       |   |       `--LITERAL_BREAK -> break [91:17]
        |       |   |           `--SEMI -> ; [91:22]
        |       |   `--RCURLY -> } [92:9]
        |       `--RCURLY -> } [93:5]
        |--METHOD_DEF -> METHOD_DEF [94:5]
        |   |--MODIFIERS -> MODIFIERS [94:5]
        |   |   `--LITERAL_STATIC -> static [94:5]
        |   |--TYPE -> TYPE [94:12]
        |   |   `--LITERAL_VOID -> void [94:12]
        |   |--IDENT -> test4 [94:17]
        |   |--LPAREN -> ( [94:22]
        |   |--PARAMETERS -> PARAMETERS [94:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [94:23]
        |   |       |--MODIFIERS -> MODIFIERS [94:23]
        |   |       |--TYPE -> TYPE [94:23]
        |   |       |   `--IDENT -> Object [94:23]
        |   |       `--IDENT -> o [94:30]
        |   |--RPAREN -> ) [94:31]
        |   `--SLIST -> { [94:33]
        |       |--LITERAL_SWITCH -> switch [95:9]
        |       |   |--LPAREN -> ( [95:16]
        |       |   |--EXPR -> EXPR [95:17]
        |       |   |   `--IDENT -> o [95:17]
        |       |   |--RPAREN -> ) [95:18]
        |       |   |--LCURLY -> { [95:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [96:13]
        |       |   |   |--LITERAL_CASE -> case [96:13]
        |       |   |   |   |--EXPR -> EXPR [96:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [96:18]
        |       |   |   |   |--COMMA -> , [96:22]
        |       |   |   |   `--LITERAL_DEFAULT -> default [96:24]
        |       |   |   |--LAMBDA -> -> [96:32]
        |       |   |   |--EXPR -> EXPR [96:53]
        |       |   |   |   `--METHOD_CALL -> ( [96:53]
        |       |   |   |       |--DOT -> . [96:45]
        |       |   |   |       |   |--DOT -> . [96:41]
        |       |   |   |       |   |   |--IDENT -> System [96:35]
        |       |   |   |       |   |   `--IDENT -> out [96:42]
        |       |   |   |       |   `--IDENT -> println [96:46]
        |       |   |   |       |--ELIST -> ELIST [96:54]
        |       |   |   |       |   `--EXPR -> EXPR [96:54]
        |       |   |   |       |       `--STRING_LITERAL -> "String, including null" [96:54]
        |       |   |   |       `--RPAREN -> ) [96:78]
        |       |   |   `--SEMI -> ; [96:79]
        |       |   `--RCURLY -> } [97:9]
        |       |--LITERAL_SWITCH -> switch [98:9]
        |       |   |--LPAREN -> ( [98:15]
        |       |   |--EXPR -> EXPR [98:16]
        |       |   |   `--IDENT -> o [98:16]
        |       |   |--RPAREN -> ) [98:17]
        |       |   |--LCURLY -> { [98:19]
        |       |   |--CASE_GROUP -> CASE_GROUP [99:13]
        |       |   |   |--LITERAL_CASE -> case [99:13]
        |       |   |   |   |--EXPR -> EXPR [99:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [99:18]
        |       |   |   |   `--COLON -> : [99:22]
        |       |   |   |--LITERAL_DEFAULT -> default [99:24]
        |       |   |   |   `--COLON -> : [99:31]
        |       |   |   `--SLIST -> SLIST [100:35]
        |       |   |       |--EXPR -> EXPR [100:35]
        |       |   |       |   `--METHOD_CALL -> ( [100:35]
        |       |   |       |       |--DOT -> . [100:27]
        |       |   |       |       |   |--DOT -> . [100:23]
        |       |   |       |       |   |   |--IDENT -> System [100:17]
        |       |   |       |       |   |   `--IDENT -> out [100:24]
        |       |   |       |       |   `--IDENT -> println [100:28]
        |       |   |       |       |--ELIST -> ELIST [100:36]
        |       |   |       |       |   `--EXPR -> EXPR [100:36]
        |       |   |       |       |       `--STRING_LITERAL -> "The rest (including null)" [100:36]
        |       |   |       |       `--RPAREN -> ) [100:63]
        |       |   |       `--SEMI -> ; [100:64]
        |       |   `--RCURLY -> } [101:9]
        |       |--LITERAL_SWITCH -> switch [102:9]
        |       |   |--LPAREN -> ( [102:15]
        |       |   |--EXPR -> EXPR [102:16]
        |       |   |   `--IDENT -> o [102:16]
        |       |   |--RPAREN -> ) [102:17]
        |       |   |--LCURLY -> { [102:19]
        |       |   |--CASE_GROUP -> CASE_GROUP [103:13]
        |       |   |   |--LITERAL_CASE -> case [103:13]
        |       |   |   |   |--EXPR -> EXPR [103:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [103:18]
        |       |   |   |   `--COLON -> : [103:22]
        |       |   |   |--LITERAL_DEFAULT -> default [103:24]
        |       |   |   |   `--COLON -> : [103:31]
        |       |   |   `--SLIST -> SLIST [104:35]
        |       |   |       |--EXPR -> EXPR [104:35]
        |       |   |       |   `--METHOD_CALL -> ( [104:35]
        |       |   |       |       |--DOT -> . [104:27]
        |       |   |       |       |   |--DOT -> . [104:23]
        |       |   |       |       |   |   |--IDENT -> System [104:17]
        |       |   |       |       |   |   `--IDENT -> out [104:24]
        |       |   |       |       |   `--IDENT -> println [104:28]
        |       |   |       |       |--ELIST -> ELIST [104:36]
        |       |   |       |       |   `--EXPR -> EXPR [104:36]
        |       |   |       |       |       `--STRING_LITERAL -> "The rest (including null)" [104:36]
        |       |   |       |       `--RPAREN -> ) [104:63]
        |       |   |       `--SEMI -> ; [104:64]
        |       |   `--RCURLY -> } [105:9]
        |       |--LITERAL_SWITCH -> switch [106:9]
        |       |   |--LPAREN -> ( [106:15]
        |       |   |--EXPR -> EXPR [106:16]
        |       |   |   `--IDENT -> o [106:16]
        |       |   |--RPAREN -> ) [106:17]
        |       |   |--LCURLY -> { [106:19]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [107:13]
        |       |   |   |--LITERAL_CASE -> case [107:13]
        |       |   |   |   |--EXPR -> EXPR [107:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [107:18]
        |       |   |   |   |--COMMA -> , [107:22]
        |       |   |   |   `--LITERAL_DEFAULT -> default [107:24]
        |       |   |   |--LAMBDA -> -> [107:32]
        |       |   |   |--EXPR -> EXPR [108:35]
        |       |   |   |   `--METHOD_CALL -> ( [108:35]
        |       |   |   |       |--DOT -> . [108:27]
        |       |   |   |       |   |--DOT -> . [108:23]
        |       |   |   |       |   |   |--IDENT -> System [108:17]
        |       |   |   |       |   |   `--IDENT -> out [108:24]
        |       |   |   |       |   `--IDENT -> println [108:28]
        |       |   |   |       |--ELIST -> ELIST [108:36]
        |       |   |   |       |   `--EXPR -> EXPR [108:36]
        |       |   |   |       |       `--STRING_LITERAL -> "The rest (including null)" [108:36]
        |       |   |   |       `--RPAREN -> ) [108:63]
        |       |   |   `--SEMI -> ; [108:64]
        |       |   `--RCURLY -> } [109:9]
        |       |--LITERAL_IF -> if [111:9]
        |       |   |--LPAREN -> ( [111:12]
        |       |   |--EXPR -> EXPR [111:35]
        |       |   |   `--LAND -> && [111:35]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [111:15]
        |       |   |       |   |--IDENT -> o [111:13]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [111:26]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [111:26]
        |       |   |       |       |--TYPE -> TYPE [111:26]
        |       |   |       |       |   `--IDENT -> String [111:26]
        |       |   |       |       `--IDENT -> s [111:33]
        |       |   |       `--GT -> > [111:49]
        |       |   |           |--METHOD_CALL -> ( [111:46]
        |       |   |           |   |--DOT -> . [111:39]
        |       |   |           |   |   |--IDENT -> s [111:38]
        |       |   |           |   |   `--IDENT -> length [111:40]
        |       |   |           |   |--ELIST -> ELIST [111:47]
        |       |   |           |   `--RPAREN -> ) [111:47]
        |       |   |           `--NUM_INT -> 1 [111:51]
        |       |   |--RPAREN -> ) [111:52]
        |       |   `--SLIST -> { [111:54]
        |       |       `--RCURLY -> } [112:9]
        |       `--RCURLY -> } [113:5]
        `--RCURLY -> } [114:1]
