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:34]
|   |   |--DOT -> . [3:28]
|   |   |   |--DOT -> . [3:24]
|   |   |   |   |--DOT -> . [3:18]
|   |   |   |   |   |--DOT -> . [3:11]
|   |   |   |   |   |   |--IDENT -> org [3:8]
|   |   |   |   |   |   `--IDENT -> apache [3:12]
|   |   |   |   |   `--IDENT -> tools [3:19]
|   |   |   |   `--IDENT -> ant [3:25]
|   |   |   `--IDENT -> types [3:29]
|   |   `--IDENT -> Path [3:35]
|   `--SEMI -> ; [3:39]
`--CLASS_DEF -> CLASS_DEF [5:1]
    |--MODIFIERS -> MODIFIERS [5:1]
    |   `--LITERAL_PUBLIC -> public [5:1]
    |--LITERAL_CLASS -> class [5:8]
    |--IDENT -> InputAntlr4AstRegressionExpressions [5:14]
    `--OBJBLOCK -> OBJBLOCK [5:50]
        |--LCURLY -> { [5:50]
        |--METHOD_DEF -> METHOD_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |   `--LITERAL_PUBLIC -> public [7:5]
        |   |--TYPE -> TYPE [7:12]
        |   |   `--LITERAL_VOID -> void [7:12]
        |   |--IDENT -> method [7:17]
        |   |--LPAREN -> ( [7:23]
        |   |--PARAMETERS -> PARAMETERS [7:24]
        |   |--RPAREN -> ) [7:24]
        |   `--SLIST -> { [7:26]
        |       |--EXPR -> EXPR [8:57]
        |       |   `--METHOD_CALL -> ( [8:57]
        |       |       |--DOT -> . [8:44]
        |       |       |   |--IDENT -> InputAntlr4AstRegressionExpressions [8:9]
        |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [8:45]
        |       |       |   |   |--GENERIC_START -> < [8:45]
        |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [8:46]
        |       |       |   |   |   `--IDENT -> Path [8:46]
        |       |       |   |   `--GENERIC_END -> > [8:50]
        |       |       |   `--IDENT -> method [8:51]
        |       |       |--ELIST -> ELIST [8:58]
        |       |       |   `--EXPR -> EXPR [8:58]
        |       |       |       `--STRING_LITERAL -> "classpath" [8:58]
        |       |       `--RPAREN -> ) [8:69]
        |       |--SEMI -> ; [8:70]
        |       `--RCURLY -> } [9:5]
        |--METHOD_DEF -> METHOD_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |   |--LITERAL_PUBLIC -> public [11:5]
        |   |   `--LITERAL_STATIC -> static [11:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [11:19]
        |   |   |--GENERIC_START -> < [11:19]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:20]
        |   |   |   `--IDENT -> T [11:20]
        |   |   `--GENERIC_END -> > [11:21]
        |   |--TYPE -> TYPE [11:23]
        |   |   `--IDENT -> T [11:23]
        |   |--IDENT -> method [11:25]
        |   |--LPAREN -> ( [11:31]
        |   |--PARAMETERS -> PARAMETERS [11:32]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [11:32]
        |   |       |--MODIFIERS -> MODIFIERS [11:32]
        |   |       |--TYPE -> TYPE [11:32]
        |   |       |   `--IDENT -> String [11:32]
        |   |       `--IDENT -> fieldName [11:39]
        |   |--RPAREN -> ) [11:48]
        |   `--SLIST -> { [11:50]
        |       |--LITERAL_RETURN -> return [12:9]
        |       |   |--EXPR -> EXPR [12:16]
        |       |   |   `--LITERAL_NULL -> null [12:16]
        |       |   `--SEMI -> ; [12:20]
        |       `--RCURLY -> } [13:5]
        |--CLASS_DEF -> CLASS_DEF [15:5]
        |   |--MODIFIERS -> MODIFIERS [15:5]
        |   |--LITERAL_CLASS -> class [15:5]
        |   |--IDENT -> B [15:11]
        |   `--OBJBLOCK -> OBJBLOCK [15:13]
        |       |--LCURLY -> { [15:13]
        |       |--METHOD_DEF -> METHOD_DEF [16:9]
        |       |   |--MODIFIERS -> MODIFIERS [16:9]
        |       |   |   `--LITERAL_PUBLIC -> public [16:9]
        |       |   |--TYPE -> TYPE [16:16]
        |       |   |   `--IDENT -> Object [16:16]
        |       |   |--IDENT -> clone [16:23]
        |       |   |--LPAREN -> ( [16:28]
        |       |   |--PARAMETERS -> PARAMETERS [16:29]
        |       |   |--RPAREN -> ) [16:29]
        |       |   |--LITERAL_THROWS -> throws [16:31]
        |       |   |   `--IDENT -> CloneNotSupportedException [16:38]
        |       |   `--SLIST -> { [16:65]
        |       |       |--EXPR -> EXPR [17:24]
        |       |       |   `--METHOD_CALL -> ( [17:24]
        |       |       |       |--DOT -> . [17:18]
        |       |       |       |   |--LITERAL_SUPER -> super [17:13]
        |       |       |       |   `--IDENT -> clone [17:19]
        |       |       |       |--ELIST -> ELIST [17:25]
        |       |       |       `--RPAREN -> ) [17:25]
        |       |       |--SEMI -> ; [17:26]
        |       |       |--LITERAL_RETURN -> return [18:13]
        |       |       |   |--EXPR -> EXPR [18:20]
        |       |       |   |   `--LITERAL_NULL -> null [18:20]
        |       |       |   `--SEMI -> ; [18:24]
        |       |       `--RCURLY -> } [19:9]
        |       |--METHOD_DEF -> METHOD_DEF [21:9]
        |       |   |--MODIFIERS -> MODIFIERS [21:9]
        |       |   |--TYPE -> TYPE [21:9]
        |       |   |   `--LITERAL_VOID -> void [21:9]
        |       |   |--IDENT -> clone [21:14]
        |       |   |--LPAREN -> ( [21:19]
        |       |   |--PARAMETERS -> PARAMETERS [21:20]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [21:20]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [21:20]
        |       |   |   |   |--TYPE -> TYPE [21:20]
        |       |   |   |   |   `--IDENT -> Object [21:20]
        |       |   |   |   `--IDENT -> asd [21:27]
        |       |   |   |--COMMA -> , [21:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:32]
        |       |   |       |--MODIFIERS -> MODIFIERS [21:32]
        |       |   |       |--TYPE -> TYPE [21:32]
        |       |   |       |   `--IDENT -> Object [21:32]
        |       |   |       `--IDENT -> asd2 [21:39]
        |       |   |--RPAREN -> ) [21:43]
        |       |   `--SLIST -> { [21:45]
        |       |       `--RCURLY -> } [22:9]
        |       `--RCURLY -> } [23:5]
        |--CLASS_DEF -> CLASS_DEF [25:5]
        |   |--MODIFIERS -> MODIFIERS [25:5]
        |   |--LITERAL_CLASS -> class [25:5]
        |   |--IDENT -> C [25:11]
        |   |--EXTENDS_CLAUSE -> extends [25:13]
        |   |   `--IDENT -> B [25:21]
        |   `--OBJBLOCK -> OBJBLOCK [25:23]
        |       |--LCURLY -> { [25:23]
        |       |--METHOD_DEF -> METHOD_DEF [26:9]
        |       |   |--MODIFIERS -> MODIFIERS [26:9]
        |       |   |--TYPE -> TYPE [26:9]
        |       |   |   `--LITERAL_VOID -> void [26:9]
        |       |   |--IDENT -> method2 [26:14]
        |       |   |--LPAREN -> ( [26:21]
        |       |   |--PARAMETERS -> PARAMETERS [26:22]
        |       |   |--RPAREN -> ) [26:22]
        |       |   `--SLIST -> { [26:24]
        |       |       |--EXPR -> EXPR [27:13]
        |       |       |   `--LITERAL_NEW -> new [27:13]
        |       |       |       |--IDENT -> Runnable [27:17]
        |       |       |       |--LPAREN -> ( [27:25]
        |       |       |       |--ELIST -> ELIST [27:26]
        |       |       |       |--RPAREN -> ) [27:26]
        |       |       |       `--OBJBLOCK -> OBJBLOCK [27:28]
        |       |       |           |--LCURLY -> { [27:28]
        |       |       |           |--METHOD_DEF -> METHOD_DEF [28:17]
        |       |       |           |   |--MODIFIERS -> MODIFIERS [28:17]
        |       |       |           |   |   |--ANNOTATION -> ANNOTATION [28:17]
        |       |       |           |   |   |   |--AT -> @ [28:17]
        |       |       |           |   |   |   `--IDENT -> Override [28:18]
        |       |       |           |   |   `--LITERAL_PUBLIC -> public [29:17]
        |       |       |           |   |--TYPE -> TYPE [29:24]
        |       |       |           |   |   `--LITERAL_VOID -> void [29:24]
        |       |       |           |   |--IDENT -> run [29:29]
        |       |       |           |   |--LPAREN -> ( [29:32]
        |       |       |           |   |--PARAMETERS -> PARAMETERS [29:33]
        |       |       |           |   |--RPAREN -> ) [29:33]
        |       |       |           |   `--SLIST -> { [29:35]
        |       |       |           |       |--EXPR -> EXPR [30:34]
        |       |       |           |       |   `--METHOD_CALL -> ( [30:34]
        |       |       |           |       |       |--DOT -> . [30:28]
        |       |       |           |       |       |   |--DOT -> . [30:22]
        |       |       |           |       |       |   |   |--IDENT -> C [30:21]
        |       |       |           |       |       |   |   `--LITERAL_SUPER -> super [30:23]
        |       |       |           |       |       |   `--IDENT -> clone [30:29]
        |       |       |           |       |       |--ELIST -> ELIST [30:35]
        |       |       |           |       |       |   |--EXPR -> EXPR [30:35]
        |       |       |           |       |       |   |   `--LITERAL_NULL -> null [30:35]
        |       |       |           |       |       |   |--COMMA -> , [30:39]
        |       |       |           |       |       |   `--EXPR -> EXPR [30:41]
        |       |       |           |       |       |       `--LITERAL_NULL -> null [30:41]
        |       |       |           |       |       `--RPAREN -> ) [30:45]
        |       |       |           |       |--SEMI -> ; [30:46]
        |       |       |           |       `--RCURLY -> } [31:17]
        |       |       |           `--RCURLY -> } [32:13]
        |       |       |--SEMI -> ; [32:14]
        |       |       `--RCURLY -> } [33:9]
        |       `--RCURLY -> } [34:5]
        `--RCURLY -> } [36:1]
