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 [3:1]
    |--MODIFIERS -> MODIFIERS [3:1]
    |   `--LITERAL_PUBLIC -> public [3:1]
    |--LITERAL_CLASS -> class [3:8]
    |--IDENT -> InputAntlr4AstRegressionPatternsInFor [3:14]
    `--OBJBLOCK -> OBJBLOCK [3:52]
        |--LCURLY -> { [3:52]
        |--METHOD_DEF -> METHOD_DEF [4:5]
        |   |--MODIFIERS -> MODIFIERS [4:5]
        |   |--TYPE -> TYPE [4:5]
        |   |   `--LITERAL_VOID -> void [4:5]
        |   |--IDENT -> m1 [4:10]
        |   |--LPAREN -> ( [4:12]
        |   |--PARAMETERS -> PARAMETERS [4:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:13]
        |   |       |--MODIFIERS -> MODIFIERS [4:13]
        |   |       |--TYPE -> TYPE [4:13]
        |   |       |   `--IDENT -> Object [4:13]
        |   |       `--IDENT -> o [4:20]
        |   |--RPAREN -> ) [4:21]
        |   `--SLIST -> { [4:23]
        |       |--LITERAL_FOR -> for [5:9]
        |       |   |--LPAREN -> ( [5:13]
        |       |   |--FOR_INIT -> FOR_INIT [5:14]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [5:14]
        |       |   |       |--MODIFIERS -> MODIFIERS [5:14]
        |       |   |       |--TYPE -> TYPE [5:14]
        |       |   |       |   `--LITERAL_INT -> int [5:14]
        |       |   |       |--IDENT -> i [5:18]
        |       |   |       `--ASSIGN -> = [5:20]
        |       |   |           `--EXPR -> EXPR [5:22]
        |       |   |               `--NUM_INT -> 0 [5:22]
        |       |   |--SEMI -> ; [5:23]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [5:52]
        |       |   |   `--EXPR -> EXPR [5:52]
        |       |   |       `--LAND -> && [5:52]
        |       |   |           |--LITERAL_INSTANCEOF -> instanceof [5:27]
        |       |   |           |   |--IDENT -> o [5:25]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [5:38]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [5:38]
        |       |   |           |       |--TYPE -> TYPE [5:38]
        |       |   |           |       |   `--IDENT -> Integer [5:38]
        |       |   |           |       `--IDENT -> myInt [5:46]
        |       |   |           `--GT -> > [5:61]
        |       |   |               |--IDENT -> myInt [5:55]
        |       |   |               `--NUM_INT -> 5 [5:63]
        |       |   |--SEMI -> ; [5:64]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [5:65]
        |       |   |--RPAREN -> ) [5:65]
        |       |   `--SLIST -> { [5:67]
        |       |       `--RCURLY -> } [7:9]
        |       |--LITERAL_FOR -> for [8:9]
        |       |   |--LPAREN -> ( [8:13]
        |       |   |--FOR_INIT -> FOR_INIT [8:14]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [8:14]
        |       |   |       |--MODIFIERS -> MODIFIERS [8:14]
        |       |   |       |--TYPE -> TYPE [8:14]
        |       |   |       |   `--LITERAL_INT -> int [8:14]
        |       |   |       |--IDENT -> i [8:18]
        |       |   |       `--ASSIGN -> = [8:20]
        |       |   |           `--EXPR -> EXPR [8:22]
        |       |   |               `--NUM_INT -> 0 [8:22]
        |       |   |--SEMI -> ; [8:23]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [8:27]
        |       |   |   `--EXPR -> EXPR [8:27]
        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [8:27]
        |       |   |           |--IDENT -> o [8:25]
        |       |   |           `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [8:38]
        |       |   |               |--MODIFIERS -> MODIFIERS [8:38]
        |       |   |               |--TYPE -> TYPE [8:38]
        |       |   |               |   `--IDENT -> Integer [8:38]
        |       |   |               `--IDENT -> myInt [8:46]
        |       |   |--SEMI -> ; [8:51]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [8:53]
        |       |   |--RPAREN -> ) [8:53]
        |       |   `--SLIST -> { [8:55]
        |       |       `--RCURLY -> } [10:9]
        |       `--RCURLY -> } [11:5]
        `--RCURLY -> } [12:1]
