COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
|--PACKAGE_DEF -> package [2:0]
|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
|   |--DOT -> . [2:47]
|   |   |--DOT -> . [2:39]
|   |   |   |--DOT -> . [2:28]
|   |   |   |   |--DOT -> . [2:22]
|   |   |   |   |   |--DOT -> . [2:11]
|   |   |   |   |   |   |--IDENT -> com [2:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:12]
|   |   |   |   |   `--IDENT -> tools [2:23]
|   |   |   |   `--IDENT -> checkstyle [2:29]
|   |   |   `--IDENT -> grammar [2:40]
|   |   `--IDENT -> java16 [2:48]
|   `--SEMI -> ; [2:54]
`--CLASS_DEF -> CLASS_DEF [4:0]
    |--MODIFIERS -> MODIFIERS [4:0]
    |   `--LITERAL_PUBLIC -> public [4:0]
    |--LITERAL_CLASS -> class [4:7]
    |--IDENT -> InputPatternVariableWithModifiers [4:13]
    `--OBJBLOCK -> OBJBLOCK [4:47]
        |--LCURLY -> { [4:47]
        |--METHOD_DEF -> METHOD_DEF [5:4]
        |   |--MODIFIERS -> MODIFIERS [5:4]
        |   |   `--LITERAL_STATIC -> static [5:4]
        |   |--TYPE -> TYPE [5:11]
        |   |   `--LITERAL_VOID -> void [5:11]
        |   |--IDENT -> method1 [5:16]
        |   |--LPAREN -> ( [5:23]
        |   |--PARAMETERS -> PARAMETERS [5:24]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [5:24]
        |   |       |--MODIFIERS -> MODIFIERS [5:24]
        |   |       |--TYPE -> TYPE [5:24]
        |   |       |   `--IDENT -> Object [5:24]
        |   |       `--IDENT -> args [5:31]
        |   |--RPAREN -> ) [5:35]
        |   `--SLIST -> { [5:37]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [6:8]
        |       |   |--MODIFIERS -> MODIFIERS [6:8]
        |       |   |--TYPE -> TYPE [6:8]
        |       |   |   `--IDENT -> Object [6:8]
        |       |   |--IDENT -> o [6:15]
        |       |   `--ASSIGN -> = [6:17]
        |       |       `--EXPR -> EXPR [6:19]
        |       |           `--IDENT -> args [6:19]
        |       |--SEMI -> ; [6:23]
        |       |--LITERAL_IF -> if [7:8]
        |       |   |--LPAREN -> ( [7:11]
        |       |   |--EXPR -> EXPR [7:14]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [7:14]
        |       |   |       |--IDENT -> o [7:12]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:25]
        |       |   |           |--MODIFIERS -> MODIFIERS [7:25]
        |       |   |           |   `--FINAL -> final [7:25]
        |       |   |           |--TYPE -> TYPE [7:31]
        |       |   |           |   |--IDENT -> String [7:31]
        |       |   |           |   `--ARRAY_DECLARATOR -> [ [7:37]
        |       |   |           |       `--RBRACK -> ] [7:38]
        |       |   |           `--IDENT -> s [7:40]
        |       |   |--RPAREN -> ) [7:41]
        |       |   |--SLIST -> { [7:42]
        |       |   |   `--RCURLY -> } [8:8]
        |       |   `--LITERAL_ELSE -> else [9:8]
        |       |       `--LITERAL_IF -> if [9:13]
        |       |           |--LPAREN -> ( [9:16]
        |       |           |--EXPR -> EXPR [9:19]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [9:19]
        |       |           |       |--IDENT -> o [9:17]
        |       |           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:30]
        |       |           |           |--MODIFIERS -> MODIFIERS [9:30]
        |       |           |           |   `--FINAL -> final [9:30]
        |       |           |           |--TYPE -> TYPE [9:36]
        |       |           |           |   |--IDENT -> Integer [9:36]
        |       |           |           |   `--ARRAY_DECLARATOR -> [ [9:43]
        |       |           |           |       `--RBRACK -> ] [9:44]
        |       |           |           `--IDENT -> i [9:46]
        |       |           |--RPAREN -> ) [9:47]
        |       |           |--SLIST -> { [9:49]
        |       |           |   `--RCURLY -> } [10:8]
        |       |           `--LITERAL_ELSE -> else [11:8]
        |       |               `--LITERAL_IF -> if [11:13]
        |       |                   |--LPAREN -> ( [11:16]
        |       |                   |--EXPR -> EXPR [11:19]
        |       |                   |   `--LITERAL_INSTANCEOF -> instanceof [11:19]
        |       |                   |       |--IDENT -> o [11:17]
        |       |                   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [11:30]
        |       |                   |           |--MODIFIERS -> MODIFIERS [11:30]
        |       |                   |           |   `--FINAL -> final [11:30]
        |       |                   |           |--TYPE -> TYPE [11:36]
        |       |                   |           |   |--IDENT -> Character [11:36]
        |       |                   |           |   `--ARRAY_DECLARATOR -> [ [11:45]
        |       |                   |           |       `--RBRACK -> ] [11:46]
        |       |                   |           `--IDENT -> c [11:48]
        |       |                   |--RPAREN -> ) [11:49]
        |       |                   |--SLIST -> { [11:50]
        |       |                   |   `--RCURLY -> } [12:8]
        |       |                   `--LITERAL_ELSE -> else [13:8]
        |       |                       `--LITERAL_IF -> if [13:13]
        |       |                           |--LPAREN -> ( [13:16]
        |       |                           |--EXPR -> EXPR [13:19]
        |       |                           |   `--LITERAL_INSTANCEOF -> instanceof [13:19]
        |       |                           |       |--IDENT -> o [13:17]
        |       |                           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [13:30]
        |       |                           |           |--MODIFIERS -> MODIFIERS [13:30]
        |       |                           |           |   `--FINAL -> final [13:30]
        |       |                           |           |--TYPE -> TYPE [13:36]
        |       |                           |           |   |--IDENT -> Double [13:36]
        |       |                           |           |   `--ARRAY_DECLARATOR -> [ [13:42]
        |       |                           |           |       `--RBRACK -> ] [13:43]
        |       |                           |           `--IDENT -> d [13:45]
        |       |                           |--RPAREN -> ) [13:46]
        |       |                           `--SLIST -> { [13:47]
        |       |                               `--RCURLY -> } [14:8]
        |       `--RCURLY -> } [15:4]
        |--METHOD_DEF -> METHOD_DEF [17:4]
        |   |--MODIFIERS -> MODIFIERS [17:4]
        |   |   `--LITERAL_STATIC -> static [17:4]
        |   |--TYPE -> TYPE [17:11]
        |   |   `--LITERAL_VOID -> void [17:11]
        |   |--IDENT -> method2 [17:16]
        |   |--LPAREN -> ( [17:23]
        |   |--PARAMETERS -> PARAMETERS [17:24]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:24]
        |   |       |--MODIFIERS -> MODIFIERS [17:24]
        |   |       |--TYPE -> TYPE [17:24]
        |   |       |   `--IDENT -> Object [17:24]
        |   |       `--IDENT -> args [17:31]
        |   |--RPAREN -> ) [17:35]
        |   `--SLIST -> { [17:37]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [18:8]
        |       |   |--MODIFIERS -> MODIFIERS [18:8]
        |       |   |--TYPE -> TYPE [18:8]
        |       |   |   `--IDENT -> Object [18:8]
        |       |   |--IDENT -> o [18:15]
        |       |   `--ASSIGN -> = [18:17]
        |       |       `--EXPR -> EXPR [18:19]
        |       |           `--IDENT -> args [18:19]
        |       |--SEMI -> ; [18:23]
        |       |--LITERAL_IF -> if [19:8]
        |       |   |--LPAREN -> ( [19:11]
        |       |   |--EXPR -> EXPR [19:14]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [19:14]
        |       |   |       |--IDENT -> o [19:12]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [19:25]
        |       |   |           |--MODIFIERS -> MODIFIERS [19:25]
        |       |   |           |--TYPE -> TYPE [19:25]
        |       |   |           |   |--IDENT -> String [19:25]
        |       |   |           |   `--ARRAY_DECLARATOR -> [ [19:31]
        |       |   |           |       `--RBRACK -> ] [19:32]
        |       |   |           `--IDENT -> s [19:34]
        |       |   |--RPAREN -> ) [19:35]
        |       |   `--SLIST -> { [19:37]
        |       |       |--EXPR -> EXPR [20:14]
        |       |       |   `--ASSIGN -> = [20:14]
        |       |       |       |--IDENT -> s [20:12]
        |       |       |       `--LITERAL_NEW -> new [20:16]
        |       |       |           |--IDENT -> String [20:20]
        |       |       |           |--ARRAY_DECLARATOR -> [ [20:26]
        |       |       |           |   `--RBRACK -> ] [20:27]
        |       |       |           `--ARRAY_INIT -> { [20:28]
        |       |       |               |--EXPR -> EXPR [20:29]
        |       |       |               |   `--STRING_LITERAL -> "modified" [20:29]
        |       |       |               `--RCURLY -> } [20:39]
        |       |       |--SEMI -> ; [20:40]
        |       |       |--EXPR -> EXPR [21:30]
        |       |       |   `--METHOD_CALL -> ( [21:30]
        |       |       |       |--DOT -> . [21:22]
        |       |       |       |   |--DOT -> . [21:18]
        |       |       |       |   |   |--IDENT -> System [21:12]
        |       |       |       |   |   `--IDENT -> out [21:19]
        |       |       |       |   `--IDENT -> println [21:23]
        |       |       |       |--ELIST -> ELIST [21:32]
        |       |       |       |   `--EXPR -> EXPR [21:32]
        |       |       |       |       `--INDEX_OP -> [ [21:32]
        |       |       |       |           |--IDENT -> s [21:31]
        |       |       |       |           |--EXPR -> EXPR [21:33]
        |       |       |       |           |   `--NUM_INT -> 0 [21:33]
        |       |       |       |           `--RBRACK -> ] [21:34]
        |       |       |       `--RPAREN -> ) [21:35]
        |       |       |--SEMI -> ; [21:36]
        |       |       `--RCURLY -> } [22:8]
        |       `--RCURLY -> } [23:4]
        `--RCURLY -> } [24:0]
