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:24]
|   |   |--DOT -> . [3:16]
|   |   |   |--DOT -> . [3:11]
|   |   |   |   |--IDENT -> java [3:7]
|   |   |   |   `--IDENT -> lang [3:12]
|   |   |   `--IDENT -> reflect [3:17]
|   |   `--IDENT -> TypeVariable [3:25]
|   `--SEMI -> ; [3:37]
|--IMPORT -> import [4:0]
|   |--DOT -> . [4:16]
|   |   |--DOT -> . [4:11]
|   |   |   |--IDENT -> java [4:7]
|   |   |   `--IDENT -> util [4:12]
|   |   `--IDENT -> List [4:17]
|   `--SEMI -> ; [4:21]
`--CLASS_DEF -> CLASS_DEF [6:0]
    |--MODIFIERS -> MODIFIERS [6:0]
    |   `--LITERAL_PUBLIC -> public [6:0]
    |--LITERAL_CLASS -> class [6:7]
    |--IDENT -> InputAntlr4AstRegressionTypeParams [6:13]
    `--OBJBLOCK -> OBJBLOCK [6:48]
        |--LCURLY -> { [6:48]
        |--METHOD_DEF -> METHOD_DEF [7:4]
        |   |--MODIFIERS -> MODIFIERS [7:4]
        |   |   `--LITERAL_PUBLIC -> public [7:4]
        |   |--TYPE -> TYPE [7:11]
        |   |   |--IDENT -> TypeVariable [7:11]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:23]
        |   |   |   |--GENERIC_START -> < [7:23]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:24]
        |   |   |   |   |--IDENT -> Class [7:24]
        |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:29]
        |   |   |   |       |--GENERIC_START -> < [7:29]
        |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:30]
        |   |   |   |       |   |--IDENT -> List [7:30]
        |   |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:34]
        |   |   |   |       |   |   |--GENERIC_START -> < [7:34]
        |   |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:35]
        |   |   |   |       |   |   |   `--IDENT -> String [7:35]
        |   |   |   |       |   |   `--GENERIC_END -> > [7:41]
        |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [7:42]
        |   |   |   |       |       `--RBRACK -> ] [7:43]
        |   |   |   |       `--GENERIC_END -> > [7:44]
        |   |   |   `--GENERIC_END -> > [7:45]
        |   |   `--ARRAY_DECLARATOR -> [ [7:46]
        |   |       `--RBRACK -> ] [7:47]
        |   |--IDENT -> getTypeParameters3 [7:49]
        |   |--LPAREN -> ( [7:67]
        |   |--PARAMETERS -> PARAMETERS [7:68]
        |   |--RPAREN -> ) [7:68]
        |   `--SLIST -> { [7:70]
        |       |--LITERAL_RETURN -> return [8:8]
        |       |   |--EXPR -> EXPR [8:15]
        |       |   |   `--LITERAL_NULL -> null [8:15]
        |       |   `--SEMI -> ; [8:19]
        |       `--RCURLY -> } [9:4]
        |--VARIABLE_DEF -> VARIABLE_DEF [11:4]
        |   |--MODIFIERS -> MODIFIERS [11:4]
        |   |--TYPE -> TYPE [11:4]
        |   |   |--IDENT -> TypeVariable [11:4]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:16]
        |   |   |   |--GENERIC_START -> < [11:16]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:17]
        |   |   |   |   |--IDENT -> Class [11:17]
        |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:22]
        |   |   |   |       |--GENERIC_START -> < [11:22]
        |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:23]
        |   |   |   |       |   |--IDENT -> List [11:23]
        |   |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:27]
        |   |   |   |       |   |   |--GENERIC_START -> < [11:27]
        |   |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:28]
        |   |   |   |       |   |   |   `--IDENT -> String [11:28]
        |   |   |   |       |   |   `--GENERIC_END -> > [11:34]
        |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [11:35]
        |   |   |   |       |       `--RBRACK -> ] [11:36]
        |   |   |   |       `--GENERIC_END -> > [11:37]
        |   |   |   `--GENERIC_END -> > [11:38]
        |   |   `--ARRAY_DECLARATOR -> [ [11:39]
        |   |       `--RBRACK -> ] [11:40]
        |   |--IDENT -> tester3 [11:42]
        |   `--SEMI -> ; [11:49]
        |--METHOD_DEF -> METHOD_DEF [13:4]
        |   |--MODIFIERS -> MODIFIERS [13:4]
        |   |   `--LITERAL_PUBLIC -> public [13:4]
        |   |--TYPE -> TYPE [13:11]
        |   |   |--IDENT -> TypeVariable [13:11]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:23]
        |   |   |   |--GENERIC_START -> < [13:23]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:24]
        |   |   |   |   |--IDENT -> Class [13:24]
        |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:29]
        |   |   |   |       |--GENERIC_START -> < [13:29]
        |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:30]
        |   |   |   |       |   `--IDENT -> String [13:30]
        |   |   |   |       `--GENERIC_END -> > [13:36]
        |   |   |   `--GENERIC_END -> > [13:37]
        |   |   `--ARRAY_DECLARATOR -> [ [13:38]
        |   |       `--RBRACK -> ] [13:39]
        |   |--IDENT -> getTypeParameters2 [13:41]
        |   |--LPAREN -> ( [13:59]
        |   |--PARAMETERS -> PARAMETERS [13:60]
        |   |--RPAREN -> ) [13:60]
        |   `--SLIST -> { [13:62]
        |       |--LITERAL_RETURN -> return [14:8]
        |       |   |--EXPR -> EXPR [14:15]
        |       |   |   `--LITERAL_NULL -> null [14:15]
        |       |   `--SEMI -> ; [14:19]
        |       `--RCURLY -> } [15:4]
        |--VARIABLE_DEF -> VARIABLE_DEF [17:4]
        |   |--MODIFIERS -> MODIFIERS [17:4]
        |   |--TYPE -> TYPE [17:4]
        |   |   |--IDENT -> TypeVariable [17:4]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:16]
        |   |   |   |--GENERIC_START -> < [17:16]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:17]
        |   |   |   |   |--IDENT -> Class [17:17]
        |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:22]
        |   |   |   |       |--GENERIC_START -> < [17:22]
        |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:23]
        |   |   |   |       |   `--IDENT -> String [17:23]
        |   |   |   |       `--GENERIC_END -> > [17:29]
        |   |   |   `--GENERIC_END -> > [17:30]
        |   |   `--ARRAY_DECLARATOR -> [ [17:31]
        |   |       `--RBRACK -> ] [17:32]
        |   |--IDENT -> tester2 [17:34]
        |   `--SEMI -> ; [17:41]
        |--METHOD_DEF -> METHOD_DEF [19:4]
        |   |--MODIFIERS -> MODIFIERS [19:4]
        |   |   `--LITERAL_PUBLIC -> public [19:4]
        |   |--TYPE -> TYPE [19:11]
        |   |   |--IDENT -> TypeVariable [19:11]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:23]
        |   |   |   |--GENERIC_START -> < [19:23]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:24]
        |   |   |   |   `--IDENT -> Class [19:24]
        |   |   |   `--GENERIC_END -> > [19:29]
        |   |   `--ARRAY_DECLARATOR -> [ [19:30]
        |   |       `--RBRACK -> ] [19:31]
        |   |--IDENT -> getTypeParameters1 [19:33]
        |   |--LPAREN -> ( [19:51]
        |   |--PARAMETERS -> PARAMETERS [19:52]
        |   |--RPAREN -> ) [19:52]
        |   `--SLIST -> { [19:54]
        |       |--LITERAL_RETURN -> return [20:8]
        |       |   |--EXPR -> EXPR [20:15]
        |       |   |   `--LITERAL_NULL -> null [20:15]
        |       |   `--SEMI -> ; [20:19]
        |       `--RCURLY -> } [21:4]
        |--VARIABLE_DEF -> VARIABLE_DEF [23:4]
        |   |--MODIFIERS -> MODIFIERS [23:4]
        |   |--TYPE -> TYPE [23:4]
        |   |   |--IDENT -> TypeVariable [23:4]
        |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:16]
        |   |   |   |--GENERIC_START -> < [23:16]
        |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:17]
        |   |   |   |   `--IDENT -> Class [23:17]
        |   |   |   `--GENERIC_END -> > [23:22]
        |   |   `--ARRAY_DECLARATOR -> [ [23:23]
        |   |       `--RBRACK -> ] [23:24]
        |   |--IDENT -> tester1 [23:26]
        |   `--SEMI -> ; [23:33]
        `--RCURLY -> } [24:0]
