COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java19 [2:49]
|   `--SEMI -> ; [2:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputJava19PatternsInNullSwitch1 [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:47]
        |--LCURLY -> { [4:47]
        |--CLASS_DEF -> CLASS_DEF [6:5]
        |   |--MODIFIERS -> MODIFIERS [6:5]
        |   |--LITERAL_CLASS -> class [6:5]
        |   |--IDENT -> Super [6:11]
        |   `--OBJBLOCK -> OBJBLOCK [6:17]
        |       |--LCURLY -> { [6:17]
        |       `--RCURLY -> } [6:18]
        |--CLASS_DEF -> CLASS_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |--LITERAL_CLASS -> class [7:5]
        |   |--IDENT -> Sub [7:11]
        |   |--EXTENDS_CLAUSE -> extends [7:15]
        |   |   `--IDENT -> Super [7:23]
        |   `--OBJBLOCK -> OBJBLOCK [7:29]
        |       |--LCURLY -> { [7:29]
        |       `--RCURLY -> } [7:30]
        |--RECORD_DEF -> RECORD_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |--LITERAL_RECORD -> record [8:5]
        |   |--IDENT -> R [8:12]
        |   |--LPAREN -> ( [8:13]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:14]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:14]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:14]
        |   |       |--TYPE -> TYPE [8:14]
        |   |       |   `--IDENT -> Super [8:14]
        |   |       `--IDENT -> s [8:20]
        |   |--RPAREN -> ) [8:21]
        |   `--OBJBLOCK -> OBJBLOCK [8:23]
        |       |--LCURLY -> { [8:23]
        |       `--RCURLY -> } [8:24]
        |--METHOD_DEF -> METHOD_DEF [10:5]
        |   |--MODIFIERS -> MODIFIERS [10:5]
        |   |   `--LITERAL_PRIVATE -> private [10:5]
        |   |--TYPE -> TYPE [10:13]
        |   |   `--LITERAL_INT -> int [10:13]
        |   |--IDENT -> matchingSwitch14 [10:17]
        |   |--LPAREN -> ( [10:33]
        |   |--PARAMETERS -> PARAMETERS [10:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:34]
        |   |       |--MODIFIERS -> MODIFIERS [10:34]
        |   |       |--TYPE -> TYPE [10:34]
        |   |       |   `--IDENT -> R [10:34]
        |   |       `--IDENT -> r [10:36]
        |   |--RPAREN -> ) [10:37]
        |   `--SLIST -> { [10:39]
        |       |--LITERAL_RETURN -> return [11:9]
        |       |   |--EXPR -> EXPR [11:16]
        |       |   |   `--LITERAL_SWITCH -> switch [11:16]
        |       |   |       |--LPAREN -> ( [11:22]
        |       |   |       |--EXPR -> EXPR [11:23]
        |       |   |       |   `--IDENT -> r [11:23]
        |       |   |       |--RPAREN -> ) [11:24]
        |       |   |       |--LCURLY -> { [11:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [12:13]
        |       |   |       |   |--LITERAL_CASE -> case [12:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [12:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [12:18]
        |       |   |       |   |       |--TYPE -> TYPE [12:18]
        |       |   |       |   |       |   `--IDENT -> R [12:18]
        |       |   |       |   |       |--LPAREN -> ( [12:19]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [12:20]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [12:20]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [12:20]
        |       |   |       |   |       |       |--TYPE -> TYPE [12:20]
        |       |   |       |   |       |       |   `--IDENT -> Super [12:20]
        |       |   |       |   |       |       `--IDENT -> s [12:26]
        |       |   |       |   |       `--RPAREN -> ) [12:27]
        |       |   |       |   |--LAMBDA -> -> [12:29]
        |       |   |       |   |--EXPR -> EXPR [12:32]
        |       |   |       |   |   `--NUM_INT -> 1 [12:32]
        |       |   |       |   `--SEMI -> ; [12:33]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [13:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [13:13]
        |       |   |       |   |--LAMBDA -> -> [13:21]
        |       |   |       |   |--EXPR -> EXPR [13:24]
        |       |   |       |   |   `--NUM_INT -> 2 [13:24]
        |       |   |       |   `--SEMI -> ; [13:25]
        |       |   |       `--RCURLY -> } [14:9]
        |       |   `--SEMI -> ; [14:10]
        |       `--RCURLY -> } [15:5]
        |--METHOD_DEF -> METHOD_DEF [17:5]
        |   |--MODIFIERS -> MODIFIERS [17:5]
        |   |   `--LITERAL_PRIVATE -> private [17:5]
        |   |--TYPE -> TYPE [17:13]
        |   |   `--LITERAL_INT -> int [17:13]
        |   |--IDENT -> matchingSwitch15 [17:17]
        |   |--LPAREN -> ( [17:33]
        |   |--PARAMETERS -> PARAMETERS [17:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:34]
        |   |       |--MODIFIERS -> MODIFIERS [17:34]
        |   |       |--TYPE -> TYPE [17:34]
        |   |       |   `--IDENT -> R [17:34]
        |   |       `--IDENT -> r [17:36]
        |   |--RPAREN -> ) [17:37]
        |   `--SLIST -> { [17:39]
        |       |--LITERAL_RETURN -> return [18:9]
        |       |   |--EXPR -> EXPR [18:16]
        |       |   |   `--LITERAL_SWITCH -> switch [18:16]
        |       |   |       |--LPAREN -> ( [18:22]
        |       |   |       |--EXPR -> EXPR [18:23]
        |       |   |       |   `--IDENT -> r [18:23]
        |       |   |       |--RPAREN -> ) [18:24]
        |       |   |       |--LCURLY -> { [18:26]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [19:13]
        |       |   |       |   |--LITERAL_CASE -> case [19:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [19:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [19:18]
        |       |   |       |   |       |--TYPE -> TYPE [19:18]
        |       |   |       |   |       |   `--IDENT -> R [19:18]
        |       |   |       |   |       |--LPAREN -> ( [19:19]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [19:20]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [19:20]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [19:20]
        |       |   |       |   |       |       |--TYPE -> TYPE [19:20]
        |       |   |       |   |       |       |   `--IDENT -> Sub [19:20]
        |       |   |       |   |       |       `--IDENT -> s [19:24]
        |       |   |       |   |       `--RPAREN -> ) [19:25]
        |       |   |       |   |--LAMBDA -> -> [19:27]
        |       |   |       |   |--EXPR -> EXPR [19:30]
        |       |   |       |   |   `--NUM_INT -> 1 [19:30]
        |       |   |       |   `--SEMI -> ; [19:31]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [20:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [20:13]
        |       |   |       |   |--LAMBDA -> -> [20:21]
        |       |   |       |   |--EXPR -> EXPR [20:24]
        |       |   |       |   |   `--NUM_INT -> 2 [20:24]
        |       |   |       |   `--SEMI -> ; [20:25]
        |       |   |       `--RCURLY -> } [21:9]
        |       |   `--SEMI -> ; [21:10]
        |       `--RCURLY -> } [22:5]
        |--METHOD_DEF -> METHOD_DEF [24:5]
        |   |--MODIFIERS -> MODIFIERS [24:5]
        |   |   `--LITERAL_PRIVATE -> private [24:5]
        |   |--TYPE -> TYPE [24:13]
        |   |   `--LITERAL_INT -> int [24:13]
        |   |--IDENT -> matchingSwitch1 [24:17]
        |   |--LPAREN -> ( [24:32]
        |   |--PARAMETERS -> PARAMETERS [24:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [24:33]
        |   |       |--MODIFIERS -> MODIFIERS [24:33]
        |   |       |--TYPE -> TYPE [24:33]
        |   |       |   `--IDENT -> Object [24:33]
        |   |       `--IDENT -> obj [24:40]
        |   |--RPAREN -> ) [24:43]
        |   `--SLIST -> { [24:45]
        |       |--LITERAL_RETURN -> return [25:9]
        |       |   |--EXPR -> EXPR [25:16]
        |       |   |   `--LITERAL_SWITCH -> switch [25:16]
        |       |   |       |--LPAREN -> ( [25:23]
        |       |   |       |--EXPR -> EXPR [25:24]
        |       |   |       |   `--IDENT -> obj [25:24]
        |       |   |       |--RPAREN -> ) [25:27]
        |       |   |       |--LCURLY -> { [25:29]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [26:13]
        |       |   |       |   |--LITERAL_CASE -> case [26:13]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [26:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [26:18]
        |       |   |       |   |       |--TYPE -> TYPE [26:18]
        |       |   |       |   |       |   `--IDENT -> String [26:18]
        |       |   |       |   |       `--IDENT -> s [26:25]
        |       |   |       |   |--LAMBDA -> -> [26:27]
        |       |   |       |   |--EXPR -> EXPR [26:38]
        |       |   |       |   |   `--METHOD_CALL -> ( [26:38]
        |       |   |       |   |       |--DOT -> . [26:31]
        |       |   |       |   |       |   |--IDENT -> s [26:30]
        |       |   |       |   |       |   `--IDENT -> length [26:32]
        |       |   |       |   |       |--ELIST -> ELIST [26:39]
        |       |   |       |   |       `--RPAREN -> ) [26:39]
        |       |   |       |   `--SEMI -> ; [26:40]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [27:13]
        |       |   |       |   |--LITERAL_CASE -> case [27:13]
        |       |   |       |   |   |--EXPR -> EXPR [27:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [27:18]
        |       |   |       |   |   |--COMMA -> , [27:22]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:24]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [27:24]
        |       |   |       |   |       |--TYPE -> TYPE [27:24]
        |       |   |       |   |       |   `--IDENT -> Integer [27:24]
        |       |   |       |   |       `--IDENT -> i [27:32]
        |       |   |       |   |--LAMBDA -> -> [27:34]
        |       |   |       |   |--EXPR -> EXPR [27:47]
        |       |   |       |   |   `--QUESTION -> ? [27:47]
        |       |   |       |   |       |--EQUAL -> == [27:39]
        |       |   |       |   |       |   |--IDENT -> i [27:37]
        |       |   |       |   |       |   `--LITERAL_NULL -> null [27:42]
        |       |   |       |   |       |--UNARY_MINUS -> - [27:49]
        |       |   |       |   |       |   `--NUM_INT -> 1 [27:50]
        |       |   |       |   |       |--COLON -> : [27:52]
        |       |   |       |   |       `--PLUS -> + [27:58]
        |       |   |       |   |           |--NUM_INT -> 100 [27:54]
        |       |   |       |   |           `--IDENT -> i [27:60]
        |       |   |       |   `--SEMI -> ; [27:61]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [28:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [28:13]
        |       |   |       |   |--LAMBDA -> -> [28:21]
        |       |   |       |   |--EXPR -> EXPR [28:24]
        |       |   |       |   |   `--UNARY_MINUS -> - [28:24]
        |       |   |       |   |       `--NUM_INT -> 2 [28:25]
        |       |   |       |   `--SEMI -> ; [28:26]
        |       |   |       `--RCURLY -> } [29:9]
        |       |   `--SEMI -> ; [29:10]
        |       `--RCURLY -> } [30:5]
        |--METHOD_DEF -> METHOD_DEF [32:5]
        |   |--MODIFIERS -> MODIFIERS [32:5]
        |   |   `--LITERAL_PRIVATE -> private [32:5]
        |   |--TYPE -> TYPE [32:13]
        |   |   `--LITERAL_INT -> int [32:13]
        |   |--IDENT -> matchingSwitch2 [32:17]
        |   |--LPAREN -> ( [32:32]
        |   |--PARAMETERS -> PARAMETERS [32:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [32:33]
        |   |       |--MODIFIERS -> MODIFIERS [32:33]
        |   |       |--TYPE -> TYPE [32:33]
        |   |       |   `--IDENT -> Object [32:33]
        |   |       `--IDENT -> obj [32:40]
        |   |--RPAREN -> ) [32:43]
        |   `--SLIST -> { [32:45]
        |       |--LITERAL_RETURN -> return [33:9]
        |       |   |--EXPR -> EXPR [33:16]
        |       |   |   `--LITERAL_SWITCH -> switch [33:16]
        |       |   |       |--LPAREN -> ( [33:23]
        |       |   |       |--EXPR -> EXPR [33:24]
        |       |   |       |   `--IDENT -> obj [33:24]
        |       |   |       |--RPAREN -> ) [33:27]
        |       |   |       |--LCURLY -> { [33:29]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [34:13]
        |       |   |       |   |--LITERAL_CASE -> case [34:13]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [34:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [34:18]
        |       |   |       |   |       |--TYPE -> TYPE [34:18]
        |       |   |       |   |       |   `--IDENT -> String [34:18]
        |       |   |       |   |       `--IDENT -> s [34:25]
        |       |   |       |   |--LAMBDA -> -> [34:27]
        |       |   |       |   |--EXPR -> EXPR [34:30]
        |       |   |       |   |   `--NUM_INT -> 0 [34:30]
        |       |   |       |   `--SEMI -> ; [34:31]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [35:13]
        |       |   |       |   |--LITERAL_CASE -> case [35:13]
        |       |   |       |   |   |--EXPR -> EXPR [35:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [35:18]
        |       |   |       |   |   |--COMMA -> , [35:22]
        |       |   |       |   |   `--LITERAL_DEFAULT -> default [35:24]
        |       |   |       |   |--LAMBDA -> -> [35:32]
        |       |   |       |   |--EXPR -> EXPR [35:35]
        |       |   |       |   |   `--NUM_INT -> 1 [35:35]
        |       |   |       |   `--SEMI -> ; [35:36]
        |       |   |       `--RCURLY -> } [36:9]
        |       |   `--SEMI -> ; [36:10]
        |       `--RCURLY -> } [37:5]
        |--METHOD_DEF -> METHOD_DEF [39:5]
        |   |--MODIFIERS -> MODIFIERS [39:5]
        |   |   `--LITERAL_PRIVATE -> private [39:5]
        |   |--TYPE -> TYPE [39:13]
        |   |   `--LITERAL_INT -> int [39:13]
        |   |--IDENT -> matchingSwitch3 [39:17]
        |   |--LPAREN -> ( [39:32]
        |   |--PARAMETERS -> PARAMETERS [39:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [39:33]
        |   |       |--MODIFIERS -> MODIFIERS [39:33]
        |   |       |--TYPE -> TYPE [39:33]
        |   |       |   `--IDENT -> Object [39:33]
        |   |       `--IDENT -> obj [39:40]
        |   |--RPAREN -> ) [39:43]
        |   `--SLIST -> { [39:45]
        |       |--LITERAL_RETURN -> return [40:9]
        |       |   |--EXPR -> EXPR [40:16]
        |       |   |   `--LITERAL_SWITCH -> switch [40:16]
        |       |   |       |--LPAREN -> ( [40:23]
        |       |   |       |--EXPR -> EXPR [40:24]
        |       |   |       |   `--IDENT -> obj [40:24]
        |       |   |       |--RPAREN -> ) [40:27]
        |       |   |       |--LCURLY -> { [40:29]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [41:13]
        |       |   |       |   |--LITERAL_CASE -> case [41:13]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [41:18]
        |       |   |       |   |       |--TYPE -> TYPE [41:18]
        |       |   |       |   |       |   `--IDENT -> String [41:18]
        |       |   |       |   |       `--IDENT -> s [41:25]
        |       |   |       |   |--LAMBDA -> -> [41:27]
        |       |   |       |   |--EXPR -> EXPR [41:38]
        |       |   |       |   |   `--METHOD_CALL -> ( [41:38]
        |       |   |       |   |       |--DOT -> . [41:31]
        |       |   |       |   |       |   |--IDENT -> s [41:30]
        |       |   |       |   |       |   `--IDENT -> length [41:32]
        |       |   |       |   |       |--ELIST -> ELIST [41:39]
        |       |   |       |   |       `--RPAREN -> ) [41:39]
        |       |   |       |   `--SEMI -> ; [41:40]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [42:13]
        |       |   |       |   |--LITERAL_CASE -> case [42:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [42:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [42:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [42:18]
        |       |   |       |   |   |   |   `--IDENT -> Integer [42:18]
        |       |   |       |   |   |   `--IDENT -> i [42:26]
        |       |   |       |   |   |--COMMA -> , [42:27]
        |       |   |       |   |   `--EXPR -> EXPR [42:29]
        |       |   |       |   |       `--LITERAL_NULL -> null [42:29]
        |       |   |       |   |--LAMBDA -> -> [42:34]
        |       |   |       |   |--EXPR -> EXPR [42:47]
        |       |   |       |   |   `--QUESTION -> ? [42:47]
        |       |   |       |   |       |--EQUAL -> == [42:39]
        |       |   |       |   |       |   |--IDENT -> i [42:37]
        |       |   |       |   |       |   `--LITERAL_NULL -> null [42:42]
        |       |   |       |   |       |--UNARY_MINUS -> - [42:49]
        |       |   |       |   |       |   `--NUM_INT -> 1 [42:50]
        |       |   |       |   |       |--COLON -> : [42:52]
        |       |   |       |   |       `--PLUS -> + [42:58]
        |       |   |       |   |           |--NUM_INT -> 100 [42:54]
        |       |   |       |   |           `--IDENT -> i [42:60]
        |       |   |       |   `--SEMI -> ; [42:61]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [43:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [43:13]
        |       |   |       |   |--LAMBDA -> -> [43:21]
        |       |   |       |   |--EXPR -> EXPR [43:24]
        |       |   |       |   |   `--UNARY_MINUS -> - [43:24]
        |       |   |       |   |       `--NUM_INT -> 2 [43:25]
        |       |   |       |   `--SEMI -> ; [43:26]
        |       |   |       `--RCURLY -> } [44:9]
        |       |   `--SEMI -> ; [44:10]
        |       `--RCURLY -> } [45:5]
        |--METHOD_DEF -> METHOD_DEF [47:5]
        |   |--MODIFIERS -> MODIFIERS [47:5]
        |   |   `--LITERAL_PRIVATE -> private [47:5]
        |   |--TYPE -> TYPE [47:13]
        |   |   `--LITERAL_INT -> int [47:13]
        |   |--IDENT -> matchingSwitch4 [47:17]
        |   |--LPAREN -> ( [47:32]
        |   |--PARAMETERS -> PARAMETERS [47:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [47:33]
        |   |       |--MODIFIERS -> MODIFIERS [47:33]
        |   |       |--TYPE -> TYPE [47:33]
        |   |       |   `--IDENT -> Object [47:33]
        |   |       `--IDENT -> obj [47:40]
        |   |--RPAREN -> ) [47:43]
        |   `--SLIST -> { [47:45]
        |       |--LITERAL_RETURN -> return [48:9]
        |       |   |--EXPR -> EXPR [48:16]
        |       |   |   `--LITERAL_SWITCH -> switch [48:16]
        |       |   |       |--LPAREN -> ( [48:23]
        |       |   |       |--EXPR -> EXPR [48:24]
        |       |   |       |   `--IDENT -> obj [48:24]
        |       |   |       |--RPAREN -> ) [48:27]
        |       |   |       |--LCURLY -> { [48:29]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [49:13]
        |       |   |       |   |--LITERAL_CASE -> case [49:13]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [49:18]
        |       |   |       |   |       |--TYPE -> TYPE [49:18]
        |       |   |       |   |       |   `--IDENT -> String [49:18]
        |       |   |       |   |       `--IDENT -> s [49:25]
        |       |   |       |   |--LAMBDA -> -> [49:27]
        |       |   |       |   |--EXPR -> EXPR [49:30]
        |       |   |       |   |   `--NUM_INT -> 0 [49:30]
        |       |   |       |   `--SEMI -> ; [49:31]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [50:13]
        |       |   |       |   |--LITERAL_CASE -> case [50:13]
        |       |   |       |   |   |--LITERAL_DEFAULT -> default [50:18]
        |       |   |       |   |   |--COMMA -> , [50:25]
        |       |   |       |   |   `--EXPR -> EXPR [50:27]
        |       |   |       |   |       `--LITERAL_NULL -> null [50:27]
        |       |   |       |   |--LAMBDA -> -> [50:32]
        |       |   |       |   |--EXPR -> EXPR [50:35]
        |       |   |       |   |   `--NUM_INT -> 1 [50:35]
        |       |   |       |   `--SEMI -> ; [50:36]
        |       |   |       `--RCURLY -> } [51:9]
        |       |   `--SEMI -> ; [51:10]
        |       `--RCURLY -> } [52:5]
        |--METHOD_DEF -> METHOD_DEF [54:5]
        |   |--MODIFIERS -> MODIFIERS [54:5]
        |   |   `--LITERAL_PRIVATE -> private [54:5]
        |   |--TYPE -> TYPE [54:13]
        |   |   `--LITERAL_INT -> int [54:13]
        |   |--IDENT -> matchingSwitch5 [54:17]
        |   |--LPAREN -> ( [54:32]
        |   |--PARAMETERS -> PARAMETERS [54:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [54:33]
        |   |       |--MODIFIERS -> MODIFIERS [54:33]
        |   |       |--TYPE -> TYPE [54:33]
        |   |       |   `--IDENT -> Object [54:33]
        |   |       `--IDENT -> obj [54:40]
        |   |--RPAREN -> ) [54:43]
        |   `--SLIST -> { [54:45]
        |       |--LITERAL_RETURN -> return [55:9]
        |       |   |--EXPR -> EXPR [55:16]
        |       |   |   `--LITERAL_SWITCH -> switch [55:16]
        |       |   |       |--LPAREN -> ( [55:23]
        |       |   |       |--EXPR -> EXPR [55:24]
        |       |   |       |   `--IDENT -> obj [55:24]
        |       |   |       |--RPAREN -> ) [55:27]
        |       |   |       |--LCURLY -> { [55:29]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [56:13]
        |       |   |       |   |--LITERAL_CASE -> case [56:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [56:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [56:18]
        |       |   |       |   |   |   |   `--IDENT -> String [56:18]
        |       |   |       |   |   |   `--IDENT -> s [56:25]
        |       |   |       |   |   `--COLON -> : [56:26]
        |       |   |       |   `--SLIST -> SLIST [56:28]
        |       |   |       |       `--LITERAL_YIELD -> yield [56:28]
        |       |   |       |           |--EXPR -> EXPR [56:42]
        |       |   |       |           |   `--METHOD_CALL -> ( [56:42]
        |       |   |       |           |       |--DOT -> . [56:35]
        |       |   |       |           |       |   |--IDENT -> s [56:34]
        |       |   |       |           |       |   `--IDENT -> length [56:36]
        |       |   |       |           |       |--ELIST -> ELIST [56:43]
        |       |   |       |           |       `--RPAREN -> ) [56:43]
        |       |   |       |           `--SEMI -> ; [56:44]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [57:13]
        |       |   |       |   |--LITERAL_CASE -> case [57:13]
        |       |   |       |   |   |--EXPR -> EXPR [57:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [57:18]
        |       |   |       |   |   `--COLON -> : [57:22]
        |       |   |       |   |--LITERAL_CASE -> case [58:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [58:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [58:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [58:18]
        |       |   |       |   |   |   |   `--IDENT -> Integer [58:18]
        |       |   |       |   |   |   `--IDENT -> i [58:26]
        |       |   |       |   |   `--COLON -> : [58:27]
        |       |   |       |   `--SLIST -> SLIST [58:29]
        |       |   |       |       `--LITERAL_YIELD -> yield [58:29]
        |       |   |       |           |--EXPR -> EXPR [58:45]
        |       |   |       |           |   `--QUESTION -> ? [58:45]
        |       |   |       |           |       |--EQUAL -> == [58:37]
        |       |   |       |           |       |   |--IDENT -> i [58:35]
        |       |   |       |           |       |   `--LITERAL_NULL -> null [58:40]
        |       |   |       |           |       |--UNARY_MINUS -> - [58:47]
        |       |   |       |           |       |   `--NUM_INT -> 1 [58:48]
        |       |   |       |           |       |--COLON -> : [58:50]
        |       |   |       |           |       `--PLUS -> + [58:56]
        |       |   |       |           |           |--NUM_INT -> 100 [58:52]
        |       |   |       |           |           `--IDENT -> i [58:58]
        |       |   |       |           `--SEMI -> ; [58:59]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [59:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [59:13]
        |       |   |       |   |   `--COLON -> : [59:20]
        |       |   |       |   `--SLIST -> SLIST [59:22]
        |       |   |       |       `--LITERAL_YIELD -> yield [59:22]
        |       |   |       |           |--EXPR -> EXPR [59:28]
        |       |   |       |           |   `--UNARY_MINUS -> - [59:28]
        |       |   |       |           |       `--NUM_INT -> 2 [59:29]
        |       |   |       |           `--SEMI -> ; [59:30]
        |       |   |       `--RCURLY -> } [60:9]
        |       |   `--SEMI -> ; [60:10]
        |       `--RCURLY -> } [61:5]
        |--METHOD_DEF -> METHOD_DEF [63:5]
        |   |--MODIFIERS -> MODIFIERS [63:5]
        |   |   `--LITERAL_PRIVATE -> private [63:5]
        |   |--TYPE -> TYPE [63:13]
        |   |   `--LITERAL_INT -> int [63:13]
        |   |--IDENT -> matchingSwitch6 [63:17]
        |   |--LPAREN -> ( [63:32]
        |   |--PARAMETERS -> PARAMETERS [63:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [63:33]
        |   |       |--MODIFIERS -> MODIFIERS [63:33]
        |   |       |--TYPE -> TYPE [63:33]
        |   |       |   `--IDENT -> Object [63:33]
        |   |       `--IDENT -> obj [63:40]
        |   |--RPAREN -> ) [63:43]
        |   `--SLIST -> { [63:45]
        |       |--LITERAL_RETURN -> return [64:9]
        |       |   |--EXPR -> EXPR [64:16]
        |       |   |   `--LITERAL_SWITCH -> switch [64:16]
        |       |   |       |--LPAREN -> ( [64:23]
        |       |   |       |--EXPR -> EXPR [64:24]
        |       |   |       |   `--IDENT -> obj [64:24]
        |       |   |       |--RPAREN -> ) [64:27]
        |       |   |       |--LCURLY -> { [64:29]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [65:13]
        |       |   |       |   |--LITERAL_CASE -> case [65:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [65:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [65:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [65:18]
        |       |   |       |   |   |   |   `--IDENT -> String [65:18]
        |       |   |       |   |   |   `--IDENT -> s [65:25]
        |       |   |       |   |   `--COLON -> : [65:26]
        |       |   |       |   `--SLIST -> SLIST [65:28]
        |       |   |       |       `--LITERAL_YIELD -> yield [65:28]
        |       |   |       |           |--EXPR -> EXPR [65:34]
        |       |   |       |           |   `--NUM_INT -> 0 [65:34]
        |       |   |       |           `--SEMI -> ; [65:35]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [66:13]
        |       |   |       |   |--LITERAL_CASE -> case [66:13]
        |       |   |       |   |   |--EXPR -> EXPR [66:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [66:18]
        |       |   |       |   |   `--COLON -> : [66:22]
        |       |   |       |   |--LITERAL_DEFAULT -> default [67:13]
        |       |   |       |   |   `--COLON -> : [67:20]
        |       |   |       |   `--SLIST -> SLIST [67:22]
        |       |   |       |       `--LITERAL_YIELD -> yield [67:22]
        |       |   |       |           |--EXPR -> EXPR [67:28]
        |       |   |       |           |   `--NUM_INT -> 1 [67:28]
        |       |   |       |           `--SEMI -> ; [67:29]
        |       |   |       `--RCURLY -> } [68:9]
        |       |   `--SEMI -> ; [68:10]
        |       `--RCURLY -> } [69:5]
        |--METHOD_DEF -> METHOD_DEF [71:5]
        |   |--MODIFIERS -> MODIFIERS [71:5]
        |   |   `--LITERAL_PRIVATE -> private [71:5]
        |   |--TYPE -> TYPE [71:13]
        |   |   `--LITERAL_INT -> int [71:13]
        |   |--IDENT -> matchingSwitch7 [71:17]
        |   |--LPAREN -> ( [71:32]
        |   |--PARAMETERS -> PARAMETERS [71:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [71:33]
        |   |       |--MODIFIERS -> MODIFIERS [71:33]
        |   |       |--TYPE -> TYPE [71:33]
        |   |       |   `--IDENT -> Object [71:33]
        |   |       `--IDENT -> obj [71:40]
        |   |--RPAREN -> ) [71:43]
        |   `--SLIST -> { [71:45]
        |       |--LITERAL_RETURN -> return [72:9]
        |       |   |--EXPR -> EXPR [72:16]
        |       |   |   `--LITERAL_SWITCH -> switch [72:16]
        |       |   |       |--LPAREN -> ( [72:23]
        |       |   |       |--EXPR -> EXPR [72:24]
        |       |   |       |   `--IDENT -> obj [72:24]
        |       |   |       |--RPAREN -> ) [72:27]
        |       |   |       |--LCURLY -> { [72:29]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [73:13]
        |       |   |       |   |--LITERAL_CASE -> case [73:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [73:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [73:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [73:18]
        |       |   |       |   |   |   |   `--IDENT -> String [73:18]
        |       |   |       |   |   |   `--IDENT -> s [73:25]
        |       |   |       |   |   `--COLON -> : [73:26]
        |       |   |       |   `--SLIST -> SLIST [73:28]
        |       |   |       |       `--LITERAL_YIELD -> yield [73:28]
        |       |   |       |           |--EXPR -> EXPR [73:42]
        |       |   |       |           |   `--METHOD_CALL -> ( [73:42]
        |       |   |       |           |       |--DOT -> . [73:35]
        |       |   |       |           |       |   |--IDENT -> s [73:34]
        |       |   |       |           |       |   `--IDENT -> length [73:36]
        |       |   |       |           |       |--ELIST -> ELIST [73:43]
        |       |   |       |           |       `--RPAREN -> ) [73:43]
        |       |   |       |           `--SEMI -> ; [73:44]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [74:13]
        |       |   |       |   |--LITERAL_CASE -> case [74:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [74:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [74:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [74:18]
        |       |   |       |   |   |   |   `--IDENT -> Integer [74:18]
        |       |   |       |   |   |   `--IDENT -> i [74:26]
        |       |   |       |   |   `--COLON -> : [74:27]
        |       |   |       |   |--LITERAL_CASE -> case [75:13]
        |       |   |       |   |   |--EXPR -> EXPR [75:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [75:18]
        |       |   |       |   |   `--COLON -> : [75:22]
        |       |   |       |   `--SLIST -> SLIST [75:24]
        |       |   |       |       `--LITERAL_YIELD -> yield [75:24]
        |       |   |       |           |--EXPR -> EXPR [75:40]
        |       |   |       |           |   `--QUESTION -> ? [75:40]
        |       |   |       |           |       |--EQUAL -> == [75:32]
        |       |   |       |           |       |   |--IDENT -> i [75:30]
        |       |   |       |           |       |   `--LITERAL_NULL -> null [75:35]
        |       |   |       |           |       |--UNARY_MINUS -> - [75:42]
        |       |   |       |           |       |   `--NUM_INT -> 1 [75:43]
        |       |   |       |           |       |--COLON -> : [75:45]
        |       |   |       |           |       `--PLUS -> + [75:51]
        |       |   |       |           |           |--NUM_INT -> 100 [75:47]
        |       |   |       |           |           `--IDENT -> i [75:53]
        |       |   |       |           `--SEMI -> ; [75:54]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [76:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [76:13]
        |       |   |       |   |   `--COLON -> : [76:20]
        |       |   |       |   `--SLIST -> SLIST [76:22]
        |       |   |       |       `--LITERAL_YIELD -> yield [76:22]
        |       |   |       |           |--EXPR -> EXPR [76:28]
        |       |   |       |           |   `--UNARY_MINUS -> - [76:28]
        |       |   |       |           |       `--NUM_INT -> 2 [76:29]
        |       |   |       |           `--SEMI -> ; [76:30]
        |       |   |       `--RCURLY -> } [77:9]
        |       |   `--SEMI -> ; [77:10]
        |       `--RCURLY -> } [78:5]
        |--METHOD_DEF -> METHOD_DEF [80:5]
        |   |--MODIFIERS -> MODIFIERS [80:5]
        |   |   `--LITERAL_PRIVATE -> private [80:5]
        |   |--TYPE -> TYPE [80:13]
        |   |   `--LITERAL_INT -> int [80:13]
        |   |--IDENT -> matchingSwitch8 [80:17]
        |   |--LPAREN -> ( [80:32]
        |   |--PARAMETERS -> PARAMETERS [80:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [80:33]
        |   |       |--MODIFIERS -> MODIFIERS [80:33]
        |   |       |--TYPE -> TYPE [80:33]
        |   |       |   `--IDENT -> Object [80:33]
        |   |       `--IDENT -> obj [80:40]
        |   |--RPAREN -> ) [80:43]
        |   `--SLIST -> { [80:45]
        |       |--LITERAL_RETURN -> return [81:9]
        |       |   |--EXPR -> EXPR [81:16]
        |       |   |   `--LITERAL_SWITCH -> switch [81:16]
        |       |   |       |--LPAREN -> ( [81:23]
        |       |   |       |--EXPR -> EXPR [81:24]
        |       |   |       |   `--IDENT -> obj [81:24]
        |       |   |       |--RPAREN -> ) [81:27]
        |       |   |       |--LCURLY -> { [81:29]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [82:13]
        |       |   |       |   |--LITERAL_CASE -> case [82:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [82:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [82:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [82:18]
        |       |   |       |   |   |   |   `--IDENT -> String [82:18]
        |       |   |       |   |   |   `--IDENT -> s [82:25]
        |       |   |       |   |   `--COLON -> : [82:26]
        |       |   |       |   `--SLIST -> SLIST [82:28]
        |       |   |       |       `--LITERAL_YIELD -> yield [82:28]
        |       |   |       |           |--EXPR -> EXPR [82:34]
        |       |   |       |           |   `--NUM_INT -> 0 [82:34]
        |       |   |       |           `--SEMI -> ; [82:35]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [83:13]
        |       |   |       |   |--LITERAL_DEFAULT -> default [83:13]
        |       |   |       |   |   `--COLON -> : [83:20]
        |       |   |       |   |--LITERAL_CASE -> case [84:13]
        |       |   |       |   |   |--EXPR -> EXPR [84:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [84:18]
        |       |   |       |   |   `--COLON -> : [84:22]
        |       |   |       |   `--SLIST -> SLIST [84:24]
        |       |   |       |       `--LITERAL_YIELD -> yield [84:24]
        |       |   |       |           |--EXPR -> EXPR [84:30]
        |       |   |       |           |   `--NUM_INT -> 1 [84:30]
        |       |   |       |           `--SEMI -> ; [84:31]
        |       |   |       `--RCURLY -> } [85:9]
        |       |   `--SEMI -> ; [85:10]
        |       `--RCURLY -> } [86:5]
        |--METHOD_DEF -> METHOD_DEF [88:5]
        |   |--MODIFIERS -> MODIFIERS [88:5]
        |   |   `--LITERAL_PRIVATE -> private [88:5]
        |   |--TYPE -> TYPE [88:13]
        |   |   `--LITERAL_INT -> int [88:13]
        |   |--IDENT -> matchingSwitch9a [88:17]
        |   |--LPAREN -> ( [88:33]
        |   |--PARAMETERS -> PARAMETERS [88:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [88:34]
        |   |       |--MODIFIERS -> MODIFIERS [88:34]
        |   |       |--TYPE -> TYPE [88:34]
        |   |       |   `--IDENT -> Object [88:34]
        |   |       `--IDENT -> obj [88:41]
        |   |--RPAREN -> ) [88:44]
        |   `--SLIST -> { [88:46]
        |       |--LITERAL_RETURN -> return [89:9]
        |       |   |--EXPR -> EXPR [89:16]
        |       |   |   `--LITERAL_SWITCH -> switch [89:16]
        |       |   |       |--LPAREN -> ( [89:23]
        |       |   |       |--EXPR -> EXPR [89:24]
        |       |   |       |   `--IDENT -> obj [89:24]
        |       |   |       |--RPAREN -> ) [89:27]
        |       |   |       |--LCURLY -> { [89:29]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [90:13]
        |       |   |       |   |--LITERAL_CASE -> case [90:13]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [90:18]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [90:18]
        |       |   |       |   |   |   |--TYPE -> TYPE [90:18]
        |       |   |       |   |   |   |   `--IDENT -> String [90:18]
        |       |   |       |   |   |   `--IDENT -> s [90:25]
        |       |   |       |   |   `--COLON -> : [90:26]
        |       |   |       |   `--SLIST -> SLIST [90:28]
        |       |   |       |       `--LITERAL_YIELD -> yield [90:28]
        |       |   |       |           |--EXPR -> EXPR [90:34]
        |       |   |       |           |   `--NUM_INT -> 0 [90:34]
        |       |   |       |           `--SEMI -> ; [90:35]
        |       |   |       |--CASE_GROUP -> CASE_GROUP [91:13]
        |       |   |       |   |--LITERAL_CASE -> case [91:13]
        |       |   |       |   |   |--EXPR -> EXPR [91:18]
        |       |   |       |   |   |   `--LITERAL_NULL -> null [91:18]
        |       |   |       |   |   |--COMMA -> , [91:22]
        |       |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [91:24]
        |       |   |       |   |   |   |--MODIFIERS -> MODIFIERS [91:24]
        |       |   |       |   |   |   |--TYPE -> TYPE [91:24]
        |       |   |       |   |   |   |   `--IDENT -> Object [91:24]
        |       |   |       |   |   |   `--IDENT -> o [91:31]
        |       |   |       |   |   `--COLON -> : [91:32]
        |       |   |       |   `--SLIST -> SLIST [91:34]
        |       |   |       |       `--LITERAL_YIELD -> yield [91:34]
        |       |   |       |           |--EXPR -> EXPR [91:40]
        |       |   |       |           |   `--NUM_INT -> 1 [91:40]
        |       |   |       |           `--SEMI -> ; [91:41]
        |       |   |       `--RCURLY -> } [92:9]
        |       |   `--SEMI -> ; [92:10]
        |       `--RCURLY -> } [93:5]
        |--METHOD_DEF -> METHOD_DEF [95:5]
        |   |--MODIFIERS -> MODIFIERS [95:5]
        |   |   `--LITERAL_PRIVATE -> private [95:5]
        |   |--TYPE -> TYPE [95:13]
        |   |   `--LITERAL_INT -> int [95:13]
        |   |--IDENT -> matchingSwitch10a [95:17]
        |   |--LPAREN -> ( [95:34]
        |   |--PARAMETERS -> PARAMETERS [95:35]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [95:35]
        |   |       |--MODIFIERS -> MODIFIERS [95:35]
        |   |       |--TYPE -> TYPE [95:35]
        |   |       |   `--IDENT -> Object [95:35]
        |   |       `--IDENT -> obj [95:42]
        |   |--RPAREN -> ) [95:45]
        |   `--SLIST -> { [95:47]
        |       |--LITERAL_SWITCH -> switch [96:9]
        |       |   |--LPAREN -> ( [96:16]
        |       |   |--EXPR -> EXPR [96:17]
        |       |   |   `--IDENT -> obj [96:17]
        |       |   |--RPAREN -> ) [96:20]
        |       |   |--LCURLY -> { [96:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [97:13]
        |       |   |   |--LITERAL_CASE -> case [97:13]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [97:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [97:18]
        |       |   |   |   |   |--TYPE -> TYPE [97:18]
        |       |   |   |   |   |   `--IDENT -> String [97:18]
        |       |   |   |   |   `--IDENT -> s [97:25]
        |       |   |   |   `--COLON -> : [97:26]
        |       |   |   `--SLIST -> SLIST [97:28]
        |       |   |       `--LITERAL_RETURN -> return [97:28]
        |       |   |           |--EXPR -> EXPR [97:35]
        |       |   |           |   `--NUM_INT -> 0 [97:35]
        |       |   |           `--SEMI -> ; [97:36]
        |       |   |--CASE_GROUP -> CASE_GROUP [98:13]
        |       |   |   |--LITERAL_CASE -> case [98:13]
        |       |   |   |   |--EXPR -> EXPR [98:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [98:18]
        |       |   |   |   |--COMMA -> , [98:22]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [98:24]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [98:24]
        |       |   |   |   |   |--TYPE -> TYPE [98:24]
        |       |   |   |   |   |   `--IDENT -> Object [98:24]
        |       |   |   |   |   `--IDENT -> o [98:31]
        |       |   |   |   `--COLON -> : [98:32]
        |       |   |   `--SLIST -> SLIST [98:34]
        |       |   |       `--LITERAL_RETURN -> return [98:34]
        |       |   |           |--EXPR -> EXPR [98:41]
        |       |   |           |   `--NUM_INT -> 1 [98:41]
        |       |   |           `--SEMI -> ; [98:42]
        |       |   `--RCURLY -> } [99:9]
        |       `--RCURLY -> } [100:5]
        `--RCURLY -> } [101:1]
