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 [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputAntlr4AstRegressionCaseDefault [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:50]
        |--LCURLY -> { [4:50]
        |--METHOD_DEF -> METHOD_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |--TYPE -> TYPE [5:5]
        |   |   `--LITERAL_VOID -> void [5:5]
        |   |--IDENT -> m1 [5:10]
        |   |--LPAREN -> ( [5:12]
        |   |--PARAMETERS -> PARAMETERS [5:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [5:13]
        |   |       |--MODIFIERS -> MODIFIERS [5:13]
        |   |       |--TYPE -> TYPE [5:13]
        |   |       |   `--IDENT -> Object [5:13]
        |   |       `--IDENT -> o [5:20]
        |   |--RPAREN -> ) [5:21]
        |   `--SLIST -> { [5:23]
        |       |--LITERAL_SWITCH -> switch [6:9]
        |       |   |--LPAREN -> ( [6:16]
        |       |   |--EXPR -> EXPR [6:17]
        |       |   |   `--IDENT -> o [6:17]
        |       |   |--RPAREN -> ) [6:18]
        |       |   |--LCURLY -> { [6:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [7:13]
        |       |   |   |--LITERAL_CASE -> case [7:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [7:27]
        |       |   |   |   |   `--LITERAL_WHEN -> when [7:27]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [7:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [7:18]
        |       |   |   |   |       |   |   `--IDENT -> String [7:18]
        |       |   |   |   |       |   `--IDENT -> s [7:25]
        |       |   |   |   |       `--EXPR -> EXPR [7:43]
        |       |   |   |   |           `--GT -> > [7:43]
        |       |   |   |   |               |--METHOD_CALL -> ( [7:40]
        |       |   |   |   |               |   |--DOT -> . [7:33]
        |       |   |   |   |               |   |   |--IDENT -> s [7:32]
        |       |   |   |   |               |   |   `--IDENT -> length [7:34]
        |       |   |   |   |               |   |--ELIST -> ELIST [7:41]
        |       |   |   |   |               |   `--RPAREN -> ) [7:41]
        |       |   |   |   |               `--NUM_INT -> 4 [7:45]
        |       |   |   |   `--COLON -> : [7:46]
        |       |   |   `--SLIST -> SLIST [8:17]
        |       |   |       `--LITERAL_BREAK -> break [8:17]
        |       |   |           `--SEMI -> ; [8:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [9:13]
        |       |   |   |--LITERAL_CASE -> case [9:13]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [9:18]
        |       |   |   |   |   |--TYPE -> TYPE [9:18]
        |       |   |   |   |   |   `--IDENT -> String [9:18]
        |       |   |   |   |   `--IDENT -> s [9:25]
        |       |   |   |   `--COLON -> : [9:26]
        |       |   |   `--SLIST -> SLIST [10:17]
        |       |   |       `--LITERAL_BREAK -> break [10:17]
        |       |   |           `--SEMI -> ; [10:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [11:13]
        |       |   |   |--LITERAL_DEFAULT -> default [11:13]
        |       |   |   |   `--COLON -> : [11:20]
        |       |   |   `--SLIST -> SLIST [12:17]
        |       |   |       `--LITERAL_THROW -> throw [12:17]
        |       |   |           |--EXPR -> EXPR [12:23]
        |       |   |           |   `--LITERAL_NEW -> new [12:23]
        |       |   |           |       |--IDENT -> UnsupportedOperationException [12:27]
        |       |   |           |       |--LPAREN -> ( [12:56]
        |       |   |           |       |--ELIST -> ELIST [12:57]
        |       |   |           |       |   `--EXPR -> EXPR [12:57]
        |       |   |           |       |       `--STRING_LITERAL -> "not supported!" [12:57]
        |       |   |           |       `--RPAREN -> ) [12:73]
        |       |   |           `--SEMI -> ; [12:74]
        |       |   `--RCURLY -> } [13:9]
        |       `--RCURLY -> } [14:5]
        |--METHOD_DEF -> METHOD_DEF [16:5]
        |   |--MODIFIERS -> MODIFIERS [16:5]
        |   |--TYPE -> TYPE [16:5]
        |   |   `--LITERAL_VOID -> void [16:5]
        |   |--IDENT -> m2 [16:10]
        |   |--LPAREN -> ( [16:12]
        |   |--PARAMETERS -> PARAMETERS [16:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [16:13]
        |   |       |--MODIFIERS -> MODIFIERS [16:13]
        |   |       |--TYPE -> TYPE [16:13]
        |   |       |   `--IDENT -> Object [16:13]
        |   |       `--IDENT -> o [16:20]
        |   |--RPAREN -> ) [16:21]
        |   `--SLIST -> { [16:23]
        |       |--LITERAL_SWITCH -> switch [17:9]
        |       |   |--LPAREN -> ( [17:16]
        |       |   |--EXPR -> EXPR [17:17]
        |       |   |   `--IDENT -> o [17:17]
        |       |   |--RPAREN -> ) [17:18]
        |       |   |--LCURLY -> { [17:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [18:13]
        |       |   |   |--LITERAL_CASE -> case [18:13]
        |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [18:27]
        |       |   |   |       `--LITERAL_WHEN -> when [18:27]
        |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [18:18]
        |       |   |   |           |   |--MODIFIERS -> MODIFIERS [18:18]
        |       |   |   |           |   |--TYPE -> TYPE [18:18]
        |       |   |   |           |   |   `--IDENT -> String [18:18]
        |       |   |   |           |   `--IDENT -> s [18:25]
        |       |   |   |           `--EXPR -> EXPR [18:43]
        |       |   |   |               `--GT -> > [18:43]
        |       |   |   |                   |--METHOD_CALL -> ( [18:40]
        |       |   |   |                   |   |--DOT -> . [18:33]
        |       |   |   |                   |   |   |--IDENT -> s [18:32]
        |       |   |   |                   |   |   `--IDENT -> length [18:34]
        |       |   |   |                   |   |--ELIST -> ELIST [18:41]
        |       |   |   |                   |   `--RPAREN -> ) [18:41]
        |       |   |   |                   `--NUM_INT -> 4 [18:45]
        |       |   |   |--LAMBDA -> -> [18:47]
        |       |   |   |--EXPR -> EXPR [19:39]
        |       |   |   |   `--METHOD_CALL -> ( [19:39]
        |       |   |   |       |--DOT -> . [19:31]
        |       |   |   |       |   |--DOT -> . [19:27]
        |       |   |   |       |   |   |--IDENT -> System [19:21]
        |       |   |   |       |   |   `--IDENT -> out [19:28]
        |       |   |   |       |   `--IDENT -> println [19:32]
        |       |   |   |       |--ELIST -> ELIST [19:40]
        |       |   |   |       |   `--EXPR -> EXPR [19:40]
        |       |   |   |       |       `--STRING_LITERAL -> "guarded pattern, `PATTERN_DEF`" [19:40]
        |       |   |   |       `--RPAREN -> ) [19:72]
        |       |   |   `--SEMI -> ; [19:73]
        |       |   |--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 -> "type pattern, no `PATTERN_DEF`" [20:49]
        |       |   |   |       `--RPAREN -> ) [20:81]
        |       |   |   `--SEMI -> ; [20:82]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [21:13]
        |       |   |   |--LITERAL_DEFAULT -> default [21:13]
        |       |   |   |--LAMBDA -> -> [21:21]
        |       |   |   `--LITERAL_THROW -> throw [21:24]
        |       |   |       |--EXPR -> EXPR [21:30]
        |       |   |       |   `--LITERAL_NEW -> new [21:30]
        |       |   |       |       |--IDENT -> UnsupportedOperationException [21:34]
        |       |   |       |       |--LPAREN -> ( [21:63]
        |       |   |       |       |--ELIST -> ELIST [21:64]
        |       |   |       |       |   `--EXPR -> EXPR [21:64]
        |       |   |       |       |       `--STRING_LITERAL -> "not supported!" [21:64]
        |       |   |       |       `--RPAREN -> ) [21:80]
        |       |   |       `--SEMI -> ; [21:81]
        |       |   `--RCURLY -> } [22:9]
        |       `--RCURLY -> } [23:5]
        |--METHOD_DEF -> METHOD_DEF [25:5]
        |   |--MODIFIERS -> MODIFIERS [25:5]
        |   |--TYPE -> TYPE [25:5]
        |   |   `--LITERAL_VOID -> void [25:5]
        |   |--IDENT -> m3 [25:10]
        |   |--LPAREN -> ( [25:12]
        |   |--PARAMETERS -> PARAMETERS [25:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:13]
        |   |       |--MODIFIERS -> MODIFIERS [25:13]
        |   |       |--TYPE -> TYPE [25:13]
        |   |       |   `--IDENT -> Object [25:13]
        |   |       `--IDENT -> o [25:20]
        |   |--RPAREN -> ) [25:21]
        |   `--SLIST -> { [25:23]
        |       |--LITERAL_SWITCH -> switch [26:9]
        |       |   |--LPAREN -> ( [26:16]
        |       |   |--EXPR -> EXPR [26:17]
        |       |   |   `--IDENT -> o [26:17]
        |       |   |--RPAREN -> ) [26:18]
        |       |   |--LCURLY -> { [26:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [27:13]
        |       |   |   |--LITERAL_CASE -> case [27:13]
        |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [27:27]
        |       |   |   |       `--LITERAL_WHEN -> when [27:27]
        |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:18]
        |       |   |   |           |   |--MODIFIERS -> MODIFIERS [27:18]
        |       |   |   |           |   |--TYPE -> TYPE [27:18]
        |       |   |   |           |   |   `--IDENT -> String [27:18]
        |       |   |   |           |   `--IDENT -> s [27:25]
        |       |   |   |           `--EXPR -> EXPR [27:43]
        |       |   |   |               `--GT -> > [27:43]
        |       |   |   |                   |--METHOD_CALL -> ( [27:40]
        |       |   |   |                   |   |--DOT -> . [27:33]
        |       |   |   |                   |   |   |--IDENT -> s [27:32]
        |       |   |   |                   |   |   `--IDENT -> length [27:34]
        |       |   |   |                   |   |--ELIST -> ELIST [27:41]
        |       |   |   |                   |   `--RPAREN -> ) [27:41]
        |       |   |   |                   `--NUM_INT -> 4 [27:45]
        |       |   |   |--LAMBDA -> -> [27:47]
        |       |   |   |--EXPR -> EXPR [28:39]
        |       |   |   |   `--METHOD_CALL -> ( [28:39]
        |       |   |   |       |--DOT -> . [28:31]
        |       |   |   |       |   |--DOT -> . [28:27]
        |       |   |   |       |   |   |--IDENT -> System [28:21]
        |       |   |   |       |   |   `--IDENT -> out [28:28]
        |       |   |   |       |   `--IDENT -> println [28:32]
        |       |   |   |       |--ELIST -> ELIST [28:40]
        |       |   |   |       |   `--EXPR -> EXPR [28:40]
        |       |   |   |       |       `--STRING_LITERAL -> "guarded pattern, `PATTERN_DEF`" [28:40]
        |       |   |   |       `--RPAREN -> ) [28:72]
        |       |   |   `--SEMI -> ; [28:73]
        |       |   |--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 [29:48]
        |       |   |   |   `--METHOD_CALL -> ( [29:48]
        |       |   |   |       |--DOT -> . [29:40]
        |       |   |   |       |   |--DOT -> . [29:36]
        |       |   |   |       |   |   |--IDENT -> System [29:30]
        |       |   |   |       |   |   `--IDENT -> out [29:37]
        |       |   |   |       |   `--IDENT -> println [29:41]
        |       |   |   |       |--ELIST -> ELIST [29:49]
        |       |   |   |       |   `--EXPR -> EXPR [29:49]
        |       |   |   |       |       `--STRING_LITERAL -> "type pattern, no `PATTERN_DEF`" [29:49]
        |       |   |   |       `--RPAREN -> ) [29:81]
        |       |   |   `--SEMI -> ; [29:82]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [30:13]
        |       |   |   |--LITERAL_CASE -> case [30:13]
        |       |   |   |   `--EXPR -> EXPR [30:18]
        |       |   |   |       `--LITERAL_NULL -> null [30:18]
        |       |   |   |--LAMBDA -> -> [30:23]
        |       |   |   `--LITERAL_THROW -> throw [30:26]
        |       |   |       |--EXPR -> EXPR [30:32]
        |       |   |       |   `--LITERAL_NEW -> new [30:32]
        |       |   |       |       |--IDENT -> UnsupportedOperationException [30:36]
        |       |   |       |       |--LPAREN -> ( [30:65]
        |       |   |       |       |--ELIST -> ELIST [30:66]
        |       |   |       |       |   `--EXPR -> EXPR [30:66]
        |       |   |       |       |       `--STRING_LITERAL -> "not supported!" [30:66]
        |       |   |       |       `--RPAREN -> ) [30:82]
        |       |   |       `--SEMI -> ; [30:83]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [31:13]
        |       |   |   |--LITERAL_DEFAULT -> default [31:13]
        |       |   |   |--LAMBDA -> -> [31:21]
        |       |   |   `--LITERAL_THROW -> throw [31:24]
        |       |   |       |--EXPR -> EXPR [31:30]
        |       |   |       |   `--LITERAL_NEW -> new [31:30]
        |       |   |       |       |--IDENT -> UnsupportedOperationException [31:34]
        |       |   |       |       |--LPAREN -> ( [31:63]
        |       |   |       |       |--ELIST -> ELIST [31:64]
        |       |   |       |       |   `--EXPR -> EXPR [31:64]
        |       |   |       |       |       `--STRING_LITERAL -> "duplicate branch!" [31:64]
        |       |   |       |       `--RPAREN -> ) [31:83]
        |       |   |       `--SEMI -> ; [31:84]
        |       |   `--RCURLY -> } [32:9]
        |       `--RCURLY -> } [33:5]
        |--METHOD_DEF -> METHOD_DEF [35:5]
        |   |--MODIFIERS -> MODIFIERS [35:5]
        |   |--TYPE -> TYPE [35:5]
        |   |   `--LITERAL_VOID -> void [35:5]
        |   |--IDENT -> m4 [35:10]
        |   |--LPAREN -> ( [35:12]
        |   |--PARAMETERS -> PARAMETERS [35:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [35:13]
        |   |       |--MODIFIERS -> MODIFIERS [35:13]
        |   |       |--TYPE -> TYPE [35:13]
        |   |       |   `--IDENT -> Object [35:13]
        |   |       `--IDENT -> o [35:20]
        |   |--RPAREN -> ) [35:21]
        |   `--SLIST -> { [35:23]
        |       |--LITERAL_SWITCH -> switch [36:9]
        |       |   |--LPAREN -> ( [36:16]
        |       |   |--EXPR -> EXPR [36:17]
        |       |   |   `--IDENT -> o [36:17]
        |       |   |--RPAREN -> ) [36:18]
        |       |   |--LCURLY -> { [36:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [37:13]
        |       |   |   |--LITERAL_CASE -> case [37:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [37:27]
        |       |   |   |   |   `--LITERAL_WHEN -> when [37:27]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [37:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [37:18]
        |       |   |   |   |       |   |   `--IDENT -> String [37:18]
        |       |   |   |   |       |   `--IDENT -> s [37:25]
        |       |   |   |   |       `--EXPR -> EXPR [37:43]
        |       |   |   |   |           `--GT -> > [37:43]
        |       |   |   |   |               |--METHOD_CALL -> ( [37:40]
        |       |   |   |   |               |   |--DOT -> . [37:33]
        |       |   |   |   |               |   |   |--IDENT -> s [37:32]
        |       |   |   |   |               |   |   `--IDENT -> length [37:34]
        |       |   |   |   |               |   |--ELIST -> ELIST [37:41]
        |       |   |   |   |               |   `--RPAREN -> ) [37:41]
        |       |   |   |   |               `--NUM_INT -> 4 [37:45]
        |       |   |   |   `--COLON -> : [37:46]
        |       |   |   `--SLIST -> SLIST [38:39]
        |       |   |       |--EXPR -> EXPR [38:39]
        |       |   |       |   `--METHOD_CALL -> ( [38:39]
        |       |   |       |       |--DOT -> . [38:31]
        |       |   |       |       |   |--DOT -> . [38:27]
        |       |   |       |       |   |   |--IDENT -> System [38:21]
        |       |   |       |       |   |   `--IDENT -> out [38:28]
        |       |   |       |       |   `--IDENT -> println [38:32]
        |       |   |       |       |--ELIST -> ELIST [38:40]
        |       |   |       |       |   `--EXPR -> EXPR [38:40]
        |       |   |       |       |       `--STRING_LITERAL -> "guarded pattern, `PATTERN_DEF`" [38:40]
        |       |   |       |       `--RPAREN -> ) [38:72]
        |       |   |       |--SEMI -> ; [38:73]
        |       |   |       `--LITERAL_BREAK -> break [39:21]
        |       |   |           `--SEMI -> ; [39:26]
        |       |   |--CASE_GROUP -> CASE_GROUP [40:13]
        |       |   |   |--LITERAL_CASE -> case [40:13]
        |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [40:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [40:18]
        |       |   |   |   |   |--TYPE -> TYPE [40:18]
        |       |   |   |   |   |   `--IDENT -> String [40:18]
        |       |   |   |   |   `--IDENT -> s [40:25]
        |       |   |   |   `--COLON -> : [40:26]
        |       |   |   `--SLIST -> SLIST [40:46]
        |       |   |       |--EXPR -> EXPR [40:46]
        |       |   |       |   `--METHOD_CALL -> ( [40:46]
        |       |   |       |       |--DOT -> . [40:38]
        |       |   |       |       |   |--DOT -> . [40:34]
        |       |   |       |       |   |   |--IDENT -> System [40:28]
        |       |   |       |       |   |   `--IDENT -> out [40:35]
        |       |   |       |       |   `--IDENT -> println [40:39]
        |       |   |       |       |--ELIST -> ELIST [40:47]
        |       |   |       |       |   `--EXPR -> EXPR [40:47]
        |       |   |       |       |       `--STRING_LITERAL -> "type pattern, no `PATTERN_DEF`" [40:47]
        |       |   |       |       `--RPAREN -> ) [40:79]
        |       |   |       |--SEMI -> ; [40:80]
        |       |   |       `--LITERAL_BREAK -> break [41:17]
        |       |   |           `--SEMI -> ; [41:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [42:13]
        |       |   |   |--LITERAL_CASE -> case [42:13]
        |       |   |   |   |--EXPR -> EXPR [42:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [42:18]
        |       |   |   |   `--COLON -> : [42:22]
        |       |   |   `--SLIST -> SLIST [42:24]
        |       |   |       `--LITERAL_THROW -> throw [42:24]
        |       |   |           |--EXPR -> EXPR [42:30]
        |       |   |           |   `--LITERAL_NEW -> new [42:30]
        |       |   |           |       |--IDENT -> UnsupportedOperationException [42:34]
        |       |   |           |       |--LPAREN -> ( [42:63]
        |       |   |           |       |--ELIST -> ELIST [42:64]
        |       |   |           |       |   `--EXPR -> EXPR [42:64]
        |       |   |           |       |       `--STRING_LITERAL -> "not supported!" [42:64]
        |       |   |           |       `--RPAREN -> ) [42:80]
        |       |   |           `--SEMI -> ; [42:81]
        |       |   |--CASE_GROUP -> CASE_GROUP [43:13]
        |       |   |   |--LITERAL_DEFAULT -> default [43:13]
        |       |   |   |   `--COLON -> : [43:20]
        |       |   |   `--SLIST -> SLIST [43:22]
        |       |   |       `--LITERAL_THROW -> throw [43:22]
        |       |   |           |--EXPR -> EXPR [43:28]
        |       |   |           |   `--LITERAL_NEW -> new [43:28]
        |       |   |           |       |--IDENT -> UnsupportedOperationException [43:32]
        |       |   |           |       |--LPAREN -> ( [43:61]
        |       |   |           |       |--ELIST -> ELIST [43:62]
        |       |   |           |       |   `--EXPR -> EXPR [43:62]
        |       |   |           |       |       `--STRING_LITERAL -> "duplicate branch!" [43:62]
        |       |   |           |       `--RPAREN -> ) [43:81]
        |       |   |           `--SEMI -> ; [43:82]
        |       |   `--RCURLY -> } [44:9]
        |       `--RCURLY -> } [45:5]
        `--RCURLY -> } [46:1]
