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]
|--IMPORT -> import [3:1]
|   |--DOT -> . [3:28]
|   |   |--DOT -> . [3:17]
|   |   |   |--DOT -> . [3:12]
|   |   |   |   |--IDENT -> java [3:8]
|   |   |   |   `--IDENT -> lang [3:13]
|   |   |   `--IDENT -> annotation [3:18]
|   |   `--IDENT -> ElementType [3:29]
|   `--SEMI -> ; [3:40]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:28]
|   |   |--DOT -> . [4:17]
|   |   |   |--DOT -> . [4:12]
|   |   |   |   |--IDENT -> java [4:8]
|   |   |   |   `--IDENT -> lang [4:13]
|   |   |   `--IDENT -> annotation [4:18]
|   |   `--IDENT -> Repeatable [4:29]
|   `--SEMI -> ; [4:39]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:28]
|   |   |--DOT -> . [5:17]
|   |   |   |--DOT -> . [5:12]
|   |   |   |   |--IDENT -> java [5:8]
|   |   |   |   `--IDENT -> lang [5:13]
|   |   |   `--IDENT -> annotation [5:18]
|   |   `--IDENT -> Target [5:29]
|   `--SEMI -> ; [5:35]
|--ANNOTATION_DEF -> ANNOTATION_DEF [8:1]
|   |--MODIFIERS -> MODIFIERS [8:1]
|   |   |--ANNOTATION -> ANNOTATION [8:1]
|   |   |   |--AT -> @ [8:1]
|   |   |   |--IDENT -> AnnotationAnnotation [8:2]
|   |   |   |--LPAREN -> ( [8:22]
|   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [8:23]
|   |   |   |   |--IDENT -> value [8:23]
|   |   |   |   |--ASSIGN -> = [8:29]
|   |   |   |   `--EXPR -> EXPR [8:31]
|   |   |   |       `--STRING_LITERAL -> "foo" [8:31]
|   |   |   `--RPAREN -> ) [8:36]
|   |   |--ANNOTATION -> ANNOTATION [9:3]
|   |   |   |--AT -> @ [9:3]
|   |   |   `--IDENT -> AnnotationAnnotation [9:4]
|   |   `--ANNOTATION -> ANNOTATION [10:1]
|   |       |--AT -> @ [10:1]
|   |       |--IDENT -> AnnotationAnnotation [10:2]
|   |       |--LPAREN -> ( [10:22]
|   |       |--EXPR -> EXPR [10:23]
|   |       |   `--STRING_LITERAL -> "bar" [10:23]
|   |       `--RPAREN -> ) [10:28]
|   |--AT -> @ [10:30]
|   |--LITERAL_INTERFACE -> interface [10:31]
|   |--IDENT -> InputAntlr4AstRegressionAnnotationLocation [10:41]
|   `--OBJBLOCK -> OBJBLOCK [10:84]
|       |--LCURLY -> { [10:84]
|       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [12:5]
|       |   |--MODIFIERS -> MODIFIERS [12:5]
|       |   |   |--ANNOTATION -> ANNOTATION [12:5]
|       |   |   |   |--AT -> @ [12:5]
|       |   |   |   |--IDENT -> AnnotationAnnotation [12:6]
|       |   |   |   |--LPAREN -> ( [12:26]
|       |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [12:27]
|       |   |   |   |   |--IDENT -> value [12:27]
|       |   |   |   |   |--ASSIGN -> = [12:33]
|       |   |   |   |   `--EXPR -> EXPR [12:35]
|       |   |   |   |       `--STRING_LITERAL -> "foo" [12:35]
|       |   |   |   `--RPAREN -> ) [12:40]
|       |   |   |--ANNOTATION -> ANNOTATION [13:7]
|       |   |   |   |--AT -> @ [13:7]
|       |   |   |   `--IDENT -> AnnotationAnnotation [13:8]
|       |   |   `--ANNOTATION -> ANNOTATION [14:5]
|       |   |       |--AT -> @ [14:5]
|       |   |       |--IDENT -> AnnotationAnnotation [14:6]
|       |   |       |--LPAREN -> ( [14:26]
|       |   |       |--EXPR -> EXPR [14:27]
|       |   |       |   `--STRING_LITERAL -> "bar" [14:27]
|       |   |       `--RPAREN -> ) [14:32]
|       |   |--TYPE -> TYPE [14:34]
|       |   |   `--IDENT -> String [14:34]
|       |   |--IDENT -> value [14:41]
|       |   |--LPAREN -> ( [14:46]
|       |   |--RPAREN -> ) [14:47]
|       |   `--SEMI -> ; [14:48]
|       `--RCURLY -> } [16:1]
|--ANNOTATION_DEF -> ANNOTATION_DEF [18:1]
|   |--MODIFIERS -> MODIFIERS [18:1]
|   |   |--ANNOTATION -> ANNOTATION [18:1]
|   |   |   |--AT -> @ [18:1]
|   |   |   |--IDENT -> Repeatable [18:2]
|   |   |   |--LPAREN -> ( [18:12]
|   |   |   |--EXPR -> EXPR [18:34]
|   |   |   |   `--DOT -> . [18:34]
|   |   |   |       |--IDENT -> AnnotationAnnotations [18:13]
|   |   |   |       `--LITERAL_CLASS -> class [18:35]
|   |   |   `--RPAREN -> ) [18:40]
|   |   `--ANNOTATION -> ANNOTATION [19:1]
|   |       |--AT -> @ [19:1]
|   |       |--IDENT -> Target [19:2]
|   |       |--LPAREN -> ( [19:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [19:9]
|   |       |   |--EXPR -> EXPR [19:21]
|   |       |   |   `--DOT -> . [19:21]
|   |       |   |       |--IDENT -> ElementType [19:10]
|   |       |   |       `--IDENT -> ANNOTATION_TYPE [19:22]
|   |       |   |--COMMA -> , [19:37]
|   |       |   |--EXPR -> EXPR [19:50]
|   |       |   |   `--DOT -> . [19:50]
|   |       |   |       |--IDENT -> ElementType [19:39]
|   |       |   |       `--IDENT -> METHOD [19:51]
|   |       |   `--RCURLY -> } [19:57]
|   |       `--RPAREN -> ) [19:58]
|   |--AT -> @ [20:1]
|   |--LITERAL_INTERFACE -> interface [20:2]
|   |--IDENT -> AnnotationAnnotation [20:12]
|   `--OBJBLOCK -> OBJBLOCK [20:34]
|       |--LCURLY -> { [20:34]
|       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [22:5]
|       |   |--MODIFIERS -> MODIFIERS [22:5]
|       |   |--TYPE -> TYPE [22:5]
|       |   |   `--IDENT -> String [22:5]
|       |   |--IDENT -> value [22:12]
|       |   |--LPAREN -> ( [22:17]
|       |   |--RPAREN -> ) [22:18]
|       |   |--LITERAL_DEFAULT -> default [22:20]
|       |   |   `--EXPR -> EXPR [22:28]
|       |   |       `--STRING_LITERAL -> "" [22:28]
|       |   `--SEMI -> ; [22:30]
|       `--RCURLY -> } [24:1]
`--ANNOTATION_DEF -> ANNOTATION_DEF [26:1]
    |--MODIFIERS -> MODIFIERS [26:1]
    |   `--ANNOTATION -> ANNOTATION [26:1]
    |       |--AT -> @ [26:1]
    |       |--IDENT -> Target [26:2]
    |       |--LPAREN -> ( [26:8]
    |       |--ANNOTATION_ARRAY_INIT -> { [26:9]
    |       |   |--EXPR -> EXPR [26:21]
    |       |   |   `--DOT -> . [26:21]
    |       |   |       |--IDENT -> ElementType [26:10]
    |       |   |       `--IDENT -> ANNOTATION_TYPE [26:22]
    |       |   |--COMMA -> , [26:37]
    |       |   |--EXPR -> EXPR [26:50]
    |       |   |   `--DOT -> . [26:50]
    |       |   |       |--IDENT -> ElementType [26:39]
    |       |   |       `--IDENT -> METHOD [26:51]
    |       |   `--RCURLY -> } [26:57]
    |       `--RPAREN -> ) [26:58]
    |--AT -> @ [27:1]
    |--LITERAL_INTERFACE -> interface [27:2]
    |--IDENT -> AnnotationAnnotations [27:12]
    `--OBJBLOCK -> OBJBLOCK [27:34]
        |--LCURLY -> { [27:34]
        |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [29:5]
        |   |--MODIFIERS -> MODIFIERS [29:5]
        |   |--TYPE -> TYPE [29:5]
        |   |   |--IDENT -> AnnotationAnnotation [29:5]
        |   |   `--ARRAY_DECLARATOR -> [ [29:25]
        |   |       `--RBRACK -> ] [29:26]
        |   |--IDENT -> value [29:28]
        |   |--LPAREN -> ( [29:33]
        |   |--RPAREN -> ) [29:34]
        |   `--SEMI -> ; [29:35]
        `--RCURLY -> } [31:1]
