COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:40]
|   |--DOT -> . [1:40]
|   |   |--DOT -> . [1:29]
|   |   |   |--DOT -> . [1:23]
|   |   |   |   |--DOT -> . [1:12]
|   |   |   |   |   |--IDENT -> com [1:9]
|   |   |   |   |   `--IDENT -> puppycrawl [1:13]
|   |   |   |   `--IDENT -> tools [1:24]
|   |   |   `--IDENT -> checkstyle [1:30]
|   |   `--IDENT -> grammar [1:41]
|   `--SEMI -> ; [1:48]
|--CLASS_DEF -> CLASS_DEF [3:1]
|   |--MODIFIERS -> MODIFIERS [3:1]
|   |   `--LITERAL_PUBLIC -> public [3:1]
|   |--LITERAL_CLASS -> class [3:8]
|   |--IDENT -> InputPatternsTrickyWhenUsage [3:14]
|   `--OBJBLOCK -> OBJBLOCK [3:43]
|       |--LCURLY -> { [3:43]
|       |--METHOD_DEF -> METHOD_DEF [4:5]
|       |   |--MODIFIERS -> MODIFIERS [4:5]
|       |   |   `--LITERAL_STATIC -> static [4:5]
|       |   |--TYPE -> TYPE [4:12]
|       |   |   `--IDENT -> String [4:12]
|       |   |--IDENT -> m1 [4:19]
|       |   |--LPAREN -> ( [4:21]
|       |   |--PARAMETERS -> PARAMETERS [4:22]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:22]
|       |   |       |--MODIFIERS -> MODIFIERS [4:22]
|       |   |       |--TYPE -> TYPE [4:22]
|       |   |       |   `--IDENT -> Object [4:22]
|       |   |       `--IDENT -> when [4:29]
|       |   |--RPAREN -> ) [4:33]
|       |   `--SLIST -> { [4:35]
|       |       |--EXPR -> EXPR [5:14]
|       |       |   `--ASSIGN -> = [5:14]
|       |       |       |--IDENT -> when [5:9]
|       |       |       `--LITERAL_NEW -> new [5:16]
|       |       |           |--IDENT -> Object [5:20]
|       |       |           |--LPAREN -> ( [5:26]
|       |       |           |--ELIST -> ELIST [5:27]
|       |       |           `--RPAREN -> ) [5:27]
|       |       |--SEMI -> ; [5:28]
|       |       |--LITERAL_RETURN -> return [6:9]
|       |       |   |--EXPR -> EXPR [6:16]
|       |       |   |   `--LITERAL_SWITCH -> switch [6:16]
|       |       |   |       |--LPAREN -> ( [6:23]
|       |       |   |       |--EXPR -> EXPR [6:24]
|       |       |   |       |   `--IDENT -> when [6:24]
|       |       |   |       |--RPAREN -> ) [6:28]
|       |       |   |       |--LCURLY -> { [6:30]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [7:13]
|       |       |   |       |   |--LITERAL_CASE -> case [7:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [7:28]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [7:28]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [7:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [7:18]
|       |       |   |       |   |           |   |   `--IDENT -> Integer [7:18]
|       |       |   |       |   |           |   `--IDENT -> i [7:26]
|       |       |   |       |   |           `--EXPR -> EXPR [7:35]
|       |       |   |       |   |               `--GE -> >= [7:35]
|       |       |   |       |   |                   |--IDENT -> i [7:33]
|       |       |   |       |   |                   `--NUM_INT -> 0 [7:38]
|       |       |   |       |   |--LAMBDA -> -> [7:40]
|       |       |   |       |   |--EXPR -> EXPR [7:53]
|       |       |   |       |   |   `--METHOD_CALL -> ( [7:53]
|       |       |   |       |   |       |--DOT -> . [7:44]
|       |       |   |       |   |       |   |--IDENT -> i [7:43]
|       |       |   |       |   |       |   `--IDENT -> toString [7:45]
|       |       |   |       |   |       |--ELIST -> ELIST [7:54]
|       |       |   |       |   |       `--RPAREN -> ) [7:54]
|       |       |   |       |   `--SEMI -> ; [7:55]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [8:13]
|       |       |   |       |   |--LITERAL_DEFAULT -> default [8:13]
|       |       |   |       |   |--LAMBDA -> -> [8:21]
|       |       |   |       |   |--EXPR -> EXPR [8:24]
|       |       |   |       |   |   `--STRING_LITERAL -> "2" [8:24]
|       |       |   |       |   `--SEMI -> ; [8:27]
|       |       |   |       `--RCURLY -> } [9:9]
|       |       |   `--SEMI -> ; [9:10]
|       |       `--RCURLY -> } [10:5]
|       |--METHOD_DEF -> METHOD_DEF [12:5]
|       |   |--MODIFIERS -> MODIFIERS [12:5]
|       |   |   `--LITERAL_STATIC -> static [12:5]
|       |   |--TYPE -> TYPE [12:12]
|       |   |   `--LITERAL_VOID -> void [12:12]
|       |   |--IDENT -> m2 [12:17]
|       |   |--LPAREN -> ( [12:19]
|       |   |--PARAMETERS -> PARAMETERS [12:20]
|       |   |--RPAREN -> ) [12:20]
|       |   `--SLIST -> { [12:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [13:9]
|       |       |   |--MODIFIERS -> MODIFIERS [13:9]
|       |       |   |--TYPE -> TYPE [13:9]
|       |       |   |   `--LITERAL_INT -> int [13:9]
|       |       |   |--IDENT -> when [13:13]
|       |       |   `--ASSIGN -> = [13:18]
|       |       |       `--EXPR -> EXPR [13:36]
|       |       |           `--METHOD_CALL -> ( [13:36]
|       |       |               |--DOT -> . [13:27]
|       |       |               |   |--IDENT -> Integer [13:20]
|       |       |               |   `--IDENT -> parseInt [13:28]
|       |       |               |--ELIST -> ELIST [13:37]
|       |       |               |   `--EXPR -> EXPR [13:37]
|       |       |               |       `--STRING_LITERAL -> "when" [13:37]
|       |       |               `--RPAREN -> ) [13:43]
|       |       |--SEMI -> ; [13:44]
|       |       `--RCURLY -> } [14:5]
|       |--METHOD_DEF -> METHOD_DEF [16:5]
|       |   |--MODIFIERS -> MODIFIERS [16:5]
|       |   |   `--LITERAL_STATIC -> static [16:5]
|       |   |--TYPE -> TYPE [16:12]
|       |   |   `--IDENT -> String [16:12]
|       |   |--IDENT -> m3 [16:19]
|       |   |--LPAREN -> ( [16:21]
|       |   |--PARAMETERS -> PARAMETERS [16:22]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [16:22]
|       |   |       |--MODIFIERS -> MODIFIERS [16:22]
|       |   |       |--TYPE -> TYPE [16:22]
|       |   |       |   `--IDENT -> Object [16:22]
|       |   |       `--IDENT -> x [16:29]
|       |   |--RPAREN -> ) [16:30]
|       |   `--SLIST -> { [16:32]
|       |       |--LITERAL_RETURN -> return [17:9]
|       |       |   |--EXPR -> EXPR [17:16]
|       |       |   |   `--LITERAL_SWITCH -> switch [17:16]
|       |       |   |       |--LPAREN -> ( [17:23]
|       |       |   |       |--EXPR -> EXPR [17:24]
|       |       |   |       |   `--IDENT -> x [17:24]
|       |       |   |       |--RPAREN -> ) [17:25]
|       |       |   |       |--LCURLY -> { [17:27]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [19:13]
|       |       |   |       |   |--LITERAL_CASE -> case [19:13]
|       |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [19:31]
|       |       |   |       |   |       `--LITERAL_WHEN -> when [19:31]
|       |       |   |       |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [19:18]
|       |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [19:18]
|       |       |   |       |   |           |   |--TYPE -> TYPE [19:18]
|       |       |   |       |   |           |   |   `--IDENT -> Integer [19:18]
|       |       |   |       |   |           |   `--IDENT -> when [19:26]
|       |       |   |       |   |           `--EXPR -> EXPR [19:41]
|       |       |   |       |   |               `--GE -> >= [19:41]
|       |       |   |       |   |                   |--IDENT -> when [19:36]
|       |       |   |       |   |                   `--NUM_INT -> 0 [19:44]
|       |       |   |       |   |--LAMBDA -> -> [19:46]
|       |       |   |       |   |--EXPR -> EXPR [19:62]
|       |       |   |       |   |   `--METHOD_CALL -> ( [19:62]
|       |       |   |       |   |       |--DOT -> . [19:53]
|       |       |   |       |   |       |   |--IDENT -> when [19:49]
|       |       |   |       |   |       |   `--IDENT -> toString [19:54]
|       |       |   |       |   |       |--ELIST -> ELIST [19:63]
|       |       |   |       |   |       `--RPAREN -> ) [19:63]
|       |       |   |       |   `--SEMI -> ; [19:64]
|       |       |   |       |--SWITCH_RULE -> SWITCH_RULE [20:13]
|       |       |   |       |   |--LITERAL_DEFAULT -> default [20:13]
|       |       |   |       |   |--LAMBDA -> -> [20:21]
|       |       |   |       |   |--EXPR -> EXPR [20:24]
|       |       |   |       |   |   `--STRING_LITERAL -> "2" [20:24]
|       |       |   |       |   `--SEMI -> ; [20:27]
|       |       |   |       `--RCURLY -> } [21:9]
|       |       |   `--SEMI -> ; [21:10]
|       |       `--RCURLY -> } [22:5]
|       |--CLASS_DEF -> CLASS_DEF [24:5]
|       |   |--MODIFIERS -> MODIFIERS [24:5]
|       |   |   |--ANNOTATION -> ANNOTATION [24:5]
|       |   |   |   |--AT -> @ [24:5]
|       |   |   |   `--IDENT -> when [24:6]
|       |   |   `--LITERAL_STATIC -> static [24:11]
|       |   |--LITERAL_CLASS -> class [24:18]
|       |   |--IDENT -> A [24:24]
|       |   `--OBJBLOCK -> OBJBLOCK [24:26]
|       |       |--LCURLY -> { [24:26]
|       |       |--CLASS_DEF -> CLASS_DEF [25:9]
|       |       |   |--MODIFIERS -> MODIFIERS [25:9]
|       |       |   |   `--LITERAL_STATIC -> static [25:9]
|       |       |   |--LITERAL_CLASS -> class [25:16]
|       |       |   |--IDENT -> when [25:22]
|       |       |   `--OBJBLOCK -> OBJBLOCK [25:26]
|       |       |       |--LCURLY -> { [25:26]
|       |       |       `--RCURLY -> } [25:27]
|       |       `--RCURLY -> } [26:5]
|       |--CLASS_DEF -> CLASS_DEF [28:5]
|       |   |--MODIFIERS -> MODIFIERS [28:5]
|       |   |   `--LITERAL_STATIC -> static [28:5]
|       |   |--LITERAL_CLASS -> class [28:12]
|       |   |--IDENT -> B [28:18]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [28:19]
|       |   |   |--GENERIC_START -> < [28:19]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [28:20]
|       |   |   |   `--IDENT -> when [28:20]
|       |   |   `--GENERIC_END -> > [28:24]
|       |   `--OBJBLOCK -> OBJBLOCK [28:26]
|       |       |--LCURLY -> { [28:26]
|       |       |--METHOD_DEF -> METHOD_DEF [29:9]
|       |       |   |--MODIFIERS -> MODIFIERS [29:9]
|       |       |   |--TYPE -> TYPE [29:9]
|       |       |   |   `--IDENT -> when [29:9]
|       |       |   |--IDENT -> getWhen [29:14]
|       |       |   |--LPAREN -> ( [29:21]
|       |       |   |--PARAMETERS -> PARAMETERS [29:22]
|       |       |   |--RPAREN -> ) [29:22]
|       |       |   `--SLIST -> { [29:24]
|       |       |       |--LITERAL_RETURN -> return [30:13]
|       |       |       |   |--EXPR -> EXPR [30:20]
|       |       |       |   |   `--LITERAL_NULL -> null [30:20]
|       |       |       |   `--SEMI -> ; [30:24]
|       |       |       `--RCURLY -> } [31:9]
|       |       `--RCURLY -> } [32:5]
|       `--RCURLY -> } [33:1]
`--ANNOTATION_DEF -> ANNOTATION_DEF [35:1]
    |--MODIFIERS -> MODIFIERS [35:1]
    |--AT -> @ [35:1]
    |--LITERAL_INTERFACE -> interface [35:2]
    |--IDENT -> when [35:12]
    `--OBJBLOCK -> OBJBLOCK [35:16]
        |--LCURLY -> { [35:16]
        `--RCURLY -> } [35:17]
