COMPILATION_UNIT -> COMPILATION_UNIT [1:0]
|--PACKAGE_DEF -> package [1:0]
|   |--ANNOTATIONS -> ANNOTATIONS [1:47]
|   |--DOT -> . [1:47]
|   |   |--DOT -> . [1:39]
|   |   |   |--DOT -> . [1:28]
|   |   |   |   |--DOT -> . [1:22]
|   |   |   |   |   |--DOT -> . [1:11]
|   |   |   |   |   |   |--IDENT -> com [1:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [1:12]
|   |   |   |   |   `--IDENT -> tools [1:23]
|   |   |   |   `--IDENT -> checkstyle [1:29]
|   |   |   `--IDENT -> grammar [1:40]
|   |   `--IDENT -> antlr4 [1:48]
|   `--SEMI -> ; [1:54]
|--IMPORT -> import [3:0]
|   |--DOT -> . [3:33]
|   |   |--DOT -> . [3:27]
|   |   |   |--DOT -> . [3:23]
|   |   |   |   |--DOT -> . [3:17]
|   |   |   |   |   |--DOT -> . [3:10]
|   |   |   |   |   |   |--IDENT -> org [3:7]
|   |   |   |   |   |   `--IDENT -> apache [3:11]
|   |   |   |   |   `--IDENT -> tools [3:18]
|   |   |   |   `--IDENT -> ant [3:24]
|   |   |   `--IDENT -> types [3:28]
|   |   `--IDENT -> Path [3:34]
|   `--SEMI -> ; [3:38]
`--CLASS_DEF -> CLASS_DEF [5:0]
    |--MODIFIERS -> MODIFIERS [5:0]
    |   `--LITERAL_PUBLIC -> public [5:0]
    |--LITERAL_CLASS -> class [5:7]
    |--IDENT -> InputAntlr4AstRegressionExpressions [5:13]
    `--OBJBLOCK -> OBJBLOCK [5:49]
        |--LCURLY -> { [5:49]
        |--METHOD_DEF -> METHOD_DEF [7:4]
        |   |--MODIFIERS -> MODIFIERS [7:4]
        |   |   `--LITERAL_PUBLIC -> public [7:4]
        |   |--TYPE -> TYPE [7:11]
        |   |   `--LITERAL_VOID -> void [7:11]
        |   |--IDENT -> method [7:16]
        |   |--LPAREN -> ( [7:22]
        |   |--PARAMETERS -> PARAMETERS [7:23]
        |   |--RPAREN -> ) [7:23]
        |   `--SLIST -> { [7:25]
        |       |--EXPR -> EXPR [8:56]
        |       |   `--METHOD_CALL -> ( [8:56]
        |       |       |--DOT -> . [8:43]
        |       |       |   |--IDENT -> InputAntlr4AstRegressionExpressions [8:8]
        |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [8:44]
        |       |       |   |   |--GENERIC_START -> < [8:44]
        |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [8:45]
        |       |       |   |   |   `--IDENT -> Path [8:45]
        |       |       |   |   `--GENERIC_END -> > [8:49]
        |       |       |   `--IDENT -> method [8:50]
        |       |       |--ELIST -> ELIST [8:57]
        |       |       |   `--EXPR -> EXPR [8:57]
        |       |       |       `--STRING_LITERAL -> "classpath" [8:57]
        |       |       `--RPAREN -> ) [8:68]
        |       |--SEMI -> ; [8:69]
        |       `--RCURLY -> } [9:4]
        |--METHOD_DEF -> METHOD_DEF [11:4]
        |   |--MODIFIERS -> MODIFIERS [11:4]
        |   |   |--LITERAL_PUBLIC -> public [11:4]
        |   |   `--LITERAL_STATIC -> static [11:11]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [11:18]
        |   |   |--GENERIC_START -> < [11:18]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:19]
        |   |   |   `--IDENT -> T [11:19]
        |   |   `--GENERIC_END -> > [11:20]
        |   |--TYPE -> TYPE [11:22]
        |   |   `--IDENT -> T [11:22]
        |   |--IDENT -> method [11:24]
        |   |--LPAREN -> ( [11:30]
        |   |--PARAMETERS -> PARAMETERS [11:31]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [11:31]
        |   |       |--MODIFIERS -> MODIFIERS [11:31]
        |   |       |--TYPE -> TYPE [11:31]
        |   |       |   `--IDENT -> String [11:31]
        |   |       `--IDENT -> fieldName [11:38]
        |   |--RPAREN -> ) [11:47]
        |   `--SLIST -> { [11:49]
        |       |--LITERAL_RETURN -> return [12:8]
        |       |   |--EXPR -> EXPR [12:15]
        |       |   |   `--LITERAL_NULL -> null [12:15]
        |       |   `--SEMI -> ; [12:19]
        |       `--RCURLY -> } [13:4]
        |--CLASS_DEF -> CLASS_DEF [15:4]
        |   |--MODIFIERS -> MODIFIERS [15:4]
        |   |--LITERAL_CLASS -> class [15:4]
        |   |--IDENT -> B [15:10]
        |   `--OBJBLOCK -> OBJBLOCK [15:12]
        |       |--LCURLY -> { [15:12]
        |       |--METHOD_DEF -> METHOD_DEF [16:8]
        |       |   |--MODIFIERS -> MODIFIERS [16:8]
        |       |   |   `--LITERAL_PUBLIC -> public [16:8]
        |       |   |--TYPE -> TYPE [16:15]
        |       |   |   `--IDENT -> Object [16:15]
        |       |   |--IDENT -> clone [16:22]
        |       |   |--LPAREN -> ( [16:27]
        |       |   |--PARAMETERS -> PARAMETERS [16:28]
        |       |   |--RPAREN -> ) [16:28]
        |       |   |--LITERAL_THROWS -> throws [16:30]
        |       |   |   `--IDENT -> CloneNotSupportedException [16:37]
        |       |   `--SLIST -> { [16:64]
        |       |       |--EXPR -> EXPR [17:23]
        |       |       |   `--METHOD_CALL -> ( [17:23]
        |       |       |       |--DOT -> . [17:17]
        |       |       |       |   |--LITERAL_SUPER -> super [17:12]
        |       |       |       |   `--IDENT -> clone [17:18]
        |       |       |       |--ELIST -> ELIST [17:24]
        |       |       |       `--RPAREN -> ) [17:24]
        |       |       |--SEMI -> ; [17:25]
        |       |       |--LITERAL_RETURN -> return [18:12]
        |       |       |   |--EXPR -> EXPR [18:19]
        |       |       |   |   `--LITERAL_NULL -> null [18:19]
        |       |       |   `--SEMI -> ; [18:23]
        |       |       `--RCURLY -> } [19:8]
        |       |--METHOD_DEF -> METHOD_DEF [21:8]
        |       |   |--MODIFIERS -> MODIFIERS [21:8]
        |       |   |--TYPE -> TYPE [21:8]
        |       |   |   `--LITERAL_VOID -> void [21:8]
        |       |   |--IDENT -> clone [21:13]
        |       |   |--LPAREN -> ( [21:18]
        |       |   |--PARAMETERS -> PARAMETERS [21:19]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [21:19]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [21:19]
        |       |   |   |   |--TYPE -> TYPE [21:19]
        |       |   |   |   |   `--IDENT -> Object [21:19]
        |       |   |   |   `--IDENT -> asd [21:26]
        |       |   |   |--COMMA -> , [21:29]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:31]
        |       |   |       |--MODIFIERS -> MODIFIERS [21:31]
        |       |   |       |--TYPE -> TYPE [21:31]
        |       |   |       |   `--IDENT -> Object [21:31]
        |       |   |       `--IDENT -> asd2 [21:38]
        |       |   |--RPAREN -> ) [21:42]
        |       |   `--SLIST -> { [21:44]
        |       |       `--RCURLY -> } [22:8]
        |       `--RCURLY -> } [23:4]
        |--CLASS_DEF -> CLASS_DEF [25:4]
        |   |--MODIFIERS -> MODIFIERS [25:4]
        |   |--LITERAL_CLASS -> class [25:4]
        |   |--IDENT -> C [25:10]
        |   |--EXTENDS_CLAUSE -> extends [25:12]
        |   |   `--IDENT -> B [25:20]
        |   `--OBJBLOCK -> OBJBLOCK [25:22]
        |       |--LCURLY -> { [25:22]
        |       |--METHOD_DEF -> METHOD_DEF [26:8]
        |       |   |--MODIFIERS -> MODIFIERS [26:8]
        |       |   |--TYPE -> TYPE [26:8]
        |       |   |   `--LITERAL_VOID -> void [26:8]
        |       |   |--IDENT -> method2 [26:13]
        |       |   |--LPAREN -> ( [26:20]
        |       |   |--PARAMETERS -> PARAMETERS [26:21]
        |       |   |--RPAREN -> ) [26:21]
        |       |   `--SLIST -> { [26:23]
        |       |       |--EXPR -> EXPR [27:12]
        |       |       |   `--LITERAL_NEW -> new [27:12]
        |       |       |       |--IDENT -> Runnable [27:16]
        |       |       |       |--LPAREN -> ( [27:24]
        |       |       |       |--ELIST -> ELIST [27:25]
        |       |       |       |--RPAREN -> ) [27:25]
        |       |       |       `--OBJBLOCK -> OBJBLOCK [27:27]
        |       |       |           |--LCURLY -> { [27:27]
        |       |       |           |--METHOD_DEF -> METHOD_DEF [28:16]
        |       |       |           |   |--MODIFIERS -> MODIFIERS [28:16]
        |       |       |           |   |   |--ANNOTATION -> ANNOTATION [28:16]
        |       |       |           |   |   |   |--AT -> @ [28:16]
        |       |       |           |   |   |   `--IDENT -> Override [28:17]
        |       |       |           |   |   `--LITERAL_PUBLIC -> public [29:16]
        |       |       |           |   |--TYPE -> TYPE [29:23]
        |       |       |           |   |   `--LITERAL_VOID -> void [29:23]
        |       |       |           |   |--IDENT -> run [29:28]
        |       |       |           |   |--LPAREN -> ( [29:31]
        |       |       |           |   |--PARAMETERS -> PARAMETERS [29:32]
        |       |       |           |   |--RPAREN -> ) [29:32]
        |       |       |           |   `--SLIST -> { [29:34]
        |       |       |           |       |--EXPR -> EXPR [30:33]
        |       |       |           |       |   `--METHOD_CALL -> ( [30:33]
        |       |       |           |       |       |--DOT -> . [30:27]
        |       |       |           |       |       |   |--DOT -> . [30:21]
        |       |       |           |       |       |   |   |--IDENT -> C [30:20]
        |       |       |           |       |       |   |   `--LITERAL_SUPER -> super [30:22]
        |       |       |           |       |       |   `--IDENT -> clone [30:28]
        |       |       |           |       |       |--ELIST -> ELIST [30:34]
        |       |       |           |       |       |   |--EXPR -> EXPR [30:34]
        |       |       |           |       |       |   |   `--LITERAL_NULL -> null [30:34]
        |       |       |           |       |       |   |--COMMA -> , [30:38]
        |       |       |           |       |       |   `--EXPR -> EXPR [30:40]
        |       |       |           |       |       |       `--LITERAL_NULL -> null [30:40]
        |       |       |           |       |       `--RPAREN -> ) [30:44]
        |       |       |           |       |--SEMI -> ; [30:45]
        |       |       |           |       `--RCURLY -> } [31:16]
        |       |       |           `--RCURLY -> } [32:12]
        |       |       |--SEMI -> ; [32:13]
        |       |       `--RCURLY -> } [33:8]
        |       `--RCURLY -> } [34:4]
        `--RCURLY -> } [36:0]
