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 -> InputPatternsAnnotationsOnBinding [3:14]
|   `--OBJBLOCK -> OBJBLOCK [3:48]
|       |--LCURLY -> { [3:48]
|       |--METHOD_DEF -> METHOD_DEF [4:9]
|       |   |--MODIFIERS -> MODIFIERS [4:9]
|       |   |   `--LITERAL_STATIC -> static [4:9]
|       |   |--TYPE -> TYPE [4:16]
|       |   |   `--LITERAL_VOID -> void [4:16]
|       |   |--IDENT -> m1 [4:21]
|       |   |--LPAREN -> ( [4:23]
|       |   |--PARAMETERS -> PARAMETERS [4:24]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:24]
|       |   |       |--MODIFIERS -> MODIFIERS [4:24]
|       |   |       |--TYPE -> TYPE [4:24]
|       |   |       |   `--IDENT -> Object [4:24]
|       |   |       `--IDENT -> o [4:31]
|       |   |--RPAREN -> ) [4:32]
|       |   `--SLIST -> { [4:34]
|       |       |--LITERAL_SWITCH -> switch [5:9]
|       |       |   |--LPAREN -> ( [5:16]
|       |       |   |--EXPR -> EXPR [5:17]
|       |       |   |   `--IDENT -> o [5:17]
|       |       |   |--RPAREN -> ) [5:18]
|       |       |   |--LCURLY -> { [5:20]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [6:13]
|       |       |   |   |--LITERAL_CASE -> case [6:13]
|       |       |   |   |   `--PATTERN_DEF -> PATTERN_DEF [6:31]
|       |       |   |   |       `--LITERAL_WHEN -> when [6:31]
|       |       |   |   |           |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [6:18]
|       |       |   |   |           |   |--MODIFIERS -> MODIFIERS [6:18]
|       |       |   |   |           |   |   `--ANNOTATION -> ANNOTATION [6:18]
|       |       |   |   |           |   |       |--AT -> @ [6:18]
|       |       |   |   |           |   |       `--IDENT -> A [6:19]
|       |       |   |   |           |   |--TYPE -> TYPE [6:21]
|       |       |   |   |           |   |   `--IDENT -> Integer [6:21]
|       |       |   |   |           |   `--IDENT -> i [6:29]
|       |       |   |   |           `--EXPR -> EXPR [6:38]
|       |       |   |   |               `--GE -> >= [6:38]
|       |       |   |   |                   |--IDENT -> i [6:36]
|       |       |   |   |                   `--NUM_INT -> 0 [6:41]
|       |       |   |   |--LAMBDA -> -> [6:43]
|       |       |   |   |--EXPR -> EXPR [6:64]
|       |       |   |   |   `--METHOD_CALL -> ( [6:64]
|       |       |   |   |       |--DOT -> . [6:56]
|       |       |   |   |       |   |--DOT -> . [6:52]
|       |       |   |   |       |   |   |--IDENT -> System [6:46]
|       |       |   |   |       |   |   `--IDENT -> out [6:53]
|       |       |   |   |       |   `--IDENT -> println [6:57]
|       |       |   |   |       |--ELIST -> ELIST [6:65]
|       |       |   |   |       |   `--EXPR -> EXPR [6:65]
|       |       |   |   |       |       `--IDENT -> i [6:65]
|       |       |   |   |       `--RPAREN -> ) [6:66]
|       |       |   |   `--SEMI -> ; [6:67]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [7:13]
|       |       |   |   |--LITERAL_CASE -> case [7:13]
|       |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:18]
|       |       |   |   |       |--MODIFIERS -> MODIFIERS [7:18]
|       |       |   |   |       |   |--ANNOTATION -> ANNOTATION [7:18]
|       |       |   |   |       |   |   |--AT -> @ [7:18]
|       |       |   |   |       |   |   `--IDENT -> A [7:19]
|       |       |   |   |       |   `--ANNOTATION -> ANNOTATION [7:21]
|       |       |   |   |       |       |--AT -> @ [7:21]
|       |       |   |   |       |       `--IDENT -> B [7:22]
|       |       |   |   |       |--TYPE -> TYPE [7:24]
|       |       |   |   |       |   `--IDENT -> Integer [7:24]
|       |       |   |   |       `--IDENT -> i [7:32]
|       |       |   |   |--LAMBDA -> -> [7:34]
|       |       |   |   |--EXPR -> EXPR [7:55]
|       |       |   |   |   `--METHOD_CALL -> ( [7:55]
|       |       |   |   |       |--DOT -> . [7:47]
|       |       |   |   |       |   |--DOT -> . [7:43]
|       |       |   |   |       |   |   |--IDENT -> System [7:37]
|       |       |   |   |       |   |   `--IDENT -> out [7:44]
|       |       |   |   |       |   `--IDENT -> println [7:48]
|       |       |   |   |       |--ELIST -> ELIST [7:58]
|       |       |   |   |       |   `--EXPR -> EXPR [7:58]
|       |       |   |   |       |       `--SL -> << [7:58]
|       |       |   |   |       |           |--IDENT -> i [7:56]
|       |       |   |   |       |           `--NUM_INT -> 1 [7:61]
|       |       |   |   |       `--RPAREN -> ) [7:62]
|       |       |   |   `--SEMI -> ; [7:63]
|       |       |   |--SWITCH_RULE -> SWITCH_RULE [8:13]
|       |       |   |   |--LITERAL_DEFAULT -> default [8:13]
|       |       |   |   |--LAMBDA -> -> [8:21]
|       |       |   |   `--LITERAL_THROW -> throw [8:24]
|       |       |   |       |--EXPR -> EXPR [8:30]
|       |       |   |       |   `--LITERAL_NEW -> new [8:30]
|       |       |   |       |       |--IDENT -> IllegalStateException [8:34]
|       |       |   |       |       |--LPAREN -> ( [8:55]
|       |       |   |       |       |--ELIST -> ELIST [9:42]
|       |       |   |       |       |   `--EXPR -> EXPR [9:42]
|       |       |   |       |       |       `--PLUS -> + [9:42]
|       |       |   |       |       |           |--STRING_LITERAL -> "Unexpected value: " [9:21]
|       |       |   |       |       |           `--IDENT -> o [9:44]
|       |       |   |       |       `--RPAREN -> ) [9:45]
|       |       |   |       `--SEMI -> ; [9:46]
|       |       |   `--RCURLY -> } [10:9]
|       |       `--RCURLY -> } [11:5]
|       `--RCURLY -> } [12:1]
|--ANNOTATION_DEF -> ANNOTATION_DEF [14:1]
|   |--MODIFIERS -> MODIFIERS [14:1]
|   |--AT -> @ [14:1]
|   |--LITERAL_INTERFACE -> interface [14:2]
|   |--IDENT -> A [14:12]
|   `--OBJBLOCK -> OBJBLOCK [14:14]
|       |--LCURLY -> { [14:14]
|       `--RCURLY -> } [14:15]
`--ANNOTATION_DEF -> ANNOTATION_DEF [15:1]
    |--MODIFIERS -> MODIFIERS [15:1]
    |--AT -> @ [15:1]
    |--LITERAL_INTERFACE -> interface [15:2]
    |--IDENT -> B [15:12]
    `--OBJBLOCK -> OBJBLOCK [15:14]
        |--LCURLY -> { [15:14]
        `--RCURLY -> } [15:15]
