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