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:16]
|   |   |--DOT -> . [3:11]
|   |   |   |--IDENT -> java [3:7]
|   |   |   `--IDENT -> util [3:12]
|   |   `--IDENT -> ArrayList [3:17]
|   `--SEMI -> ; [3:26]
|--IMPORT -> import [4:0]
|   |--DOT -> . [4:16]
|   |   |--DOT -> . [4:11]
|   |   |   |--IDENT -> java [4:7]
|   |   |   `--IDENT -> util [4:12]
|   |   `--IDENT -> Collections [4:17]
|   `--SEMI -> ; [4:28]
|--IMPORT -> import [5:0]
|   |--DOT -> . [5:16]
|   |   |--DOT -> . [5:11]
|   |   |   |--IDENT -> java [5:7]
|   |   |   `--IDENT -> util [5:12]
|   |   `--IDENT -> HashMap [5:17]
|   `--SEMI -> ; [5:24]
|--IMPORT -> import [6:0]
|   |--DOT -> . [6:16]
|   |   |--DOT -> . [6:11]
|   |   |   |--IDENT -> java [6:7]
|   |   |   `--IDENT -> util [6:12]
|   |   `--IDENT -> List [6:17]
|   `--SEMI -> ; [6:21]
|--IMPORT -> import [7:0]
|   |--DOT -> . [7:16]
|   |   |--DOT -> . [7:11]
|   |   |   |--IDENT -> java [7:7]
|   |   |   `--IDENT -> util [7:12]
|   |   `--IDENT -> Map [7:17]
|   `--SEMI -> ; [7:20]
|--IMPORT -> import [8:0]
|   |--DOT -> . [8:27]
|   |   |--DOT -> . [8:16]
|   |   |   |--DOT -> . [8:11]
|   |   |   |   |--IDENT -> java [8:7]
|   |   |   |   `--IDENT -> util [8:12]
|   |   |   `--IDENT -> concurrent [8:17]
|   |   `--IDENT -> Callable [8:28]
|   `--SEMI -> ; [8:36]
|--CLASS_DEF -> CLASS_DEF [10:0]
|   |--MODIFIERS -> MODIFIERS [10:0]
|   |   `--LITERAL_PUBLIC -> public [10:0]
|   |--LITERAL_CLASS -> class [10:7]
|   |--IDENT -> InputAntlr4AstRegressionWeirdCtor [10:13]
|   `--OBJBLOCK -> OBJBLOCK [10:47]
|       |--LCURLY -> { [10:47]
|       |--METHOD_DEF -> METHOD_DEF [11:4]
|       |   |--MODIFIERS -> MODIFIERS [11:4]
|       |   |--TYPE -> TYPE [11:4]
|       |   |   `--LITERAL_VOID -> void [11:4]
|       |   |--IDENT -> meth [11:9]
|       |   |--LPAREN -> ( [11:13]
|       |   |--PARAMETERS -> PARAMETERS [11:14]
|       |   |--RPAREN -> ) [11:14]
|       |   `--SLIST -> { [12:4]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [13:8]
|       |       |   |--MODIFIERS -> MODIFIERS [13:8]
|       |       |   |--TYPE -> TYPE [13:8]
|       |       |   |   |--IDENT -> List [13:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:12]
|       |       |   |       |--GENERIC_START -> < [13:12]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:13]
|       |       |   |       |   `--IDENT -> Integer [13:13]
|       |       |   |       `--GENERIC_END -> > [13:20]
|       |       |   |--IDENT -> x [13:22]
|       |       |   `--ASSIGN -> = [13:24]
|       |       |       `--EXPR -> EXPR [13:26]
|       |       |           `--LITERAL_NEW -> new [13:26]
|       |       |               |--IDENT -> ArrayList [13:30]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:39]
|       |       |               |   |--GENERIC_START -> < [13:39]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:40]
|       |       |               |   |   `--IDENT -> Integer [13:40]
|       |       |               |   `--GENERIC_END -> > [13:47]
|       |       |               |--LPAREN -> ( [13:48]
|       |       |               |--ELIST -> ELIST [13:49]
|       |       |               `--RPAREN -> ) [13:49]
|       |       |--SEMI -> ; [13:50]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [14:8]
|       |       |   |--MODIFIERS -> MODIFIERS [14:8]
|       |       |   |--TYPE -> TYPE [14:8]
|       |       |   |   |--IDENT -> List [14:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:12]
|       |       |   |       |--GENERIC_START -> < [14:12]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:13]
|       |       |   |       |   |--IDENT -> List [14:13]
|       |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:17]
|       |       |   |       |       |--GENERIC_START -> < [14:17]
|       |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:18]
|       |       |   |       |       |   `--IDENT -> Integer [14:18]
|       |       |   |       |       `--GENERIC_END -> > [14:25]
|       |       |   |       `--GENERIC_END -> > [14:26]
|       |       |   |--IDENT -> y [14:28]
|       |       |   `--ASSIGN -> = [14:30]
|       |       |       `--EXPR -> EXPR [14:32]
|       |       |           `--LITERAL_NEW -> new [14:32]
|       |       |               |--IDENT -> ArrayList [14:36]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:45]
|       |       |               |   |--GENERIC_START -> < [14:45]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:46]
|       |       |               |   |   |--IDENT -> List [14:46]
|       |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:50]
|       |       |               |   |       |--GENERIC_START -> < [14:50]
|       |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:51]
|       |       |               |   |       |   `--IDENT -> Integer [14:51]
|       |       |               |   |       `--GENERIC_END -> > [14:58]
|       |       |               |   `--GENERIC_END -> > [14:59]
|       |       |               |--LPAREN -> ( [14:60]
|       |       |               |--ELIST -> ELIST [14:61]
|       |       |               `--RPAREN -> ) [14:61]
|       |       |--SEMI -> ; [14:62]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
|       |       |   |--MODIFIERS -> MODIFIERS [15:8]
|       |       |   |--TYPE -> TYPE [15:8]
|       |       |   |   |--IDENT -> List [15:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:13]
|       |       |   |       |--GENERIC_START -> < [15:13]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:15]
|       |       |   |       |   `--IDENT -> Integer [15:15]
|       |       |   |       `--GENERIC_END -> > [15:23]
|       |       |   |--IDENT -> a [15:25]
|       |       |   `--ASSIGN -> = [15:27]
|       |       |       `--EXPR -> EXPR [15:29]
|       |       |           `--LITERAL_NEW -> new [15:29]
|       |       |               |--IDENT -> ArrayList [15:33]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:43]
|       |       |               |   |--GENERIC_START -> < [15:43]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:45]
|       |       |               |   |   `--IDENT -> Integer [15:45]
|       |       |               |   `--GENERIC_END -> > [15:53]
|       |       |               |--LPAREN -> ( [15:55]
|       |       |               |--ELIST -> ELIST [15:56]
|       |       |               `--RPAREN -> ) [15:56]
|       |       |--SEMI -> ; [15:57]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [16:8]
|       |       |   |--MODIFIERS -> MODIFIERS [16:8]
|       |       |   |--TYPE -> TYPE [16:8]
|       |       |   |   |--IDENT -> List [16:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:13]
|       |       |   |       |--GENERIC_START -> < [16:13]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:15]
|       |       |   |       |   |--IDENT -> List [16:15]
|       |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:20]
|       |       |   |       |       |--GENERIC_START -> < [16:20]
|       |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:22]
|       |       |   |       |       |   `--IDENT -> Integer [16:22]
|       |       |   |       |       `--GENERIC_END -> > [16:30]
|       |       |   |       `--GENERIC_END -> > [16:32]
|       |       |   |--IDENT -> b [16:34]
|       |       |   `--ASSIGN -> = [16:36]
|       |       |       `--EXPR -> EXPR [16:38]
|       |       |           `--LITERAL_NEW -> new [16:38]
|       |       |               |--IDENT -> ArrayList [16:42]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:52]
|       |       |               |   |--GENERIC_START -> < [16:52]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:54]
|       |       |               |   |   |--IDENT -> List [16:54]
|       |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:59]
|       |       |               |   |       |--GENERIC_START -> < [16:59]
|       |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:61]
|       |       |               |   |       |   `--IDENT -> Integer [16:61]
|       |       |               |   |       `--GENERIC_END -> > [16:69]
|       |       |               |   `--GENERIC_END -> > [16:71]
|       |       |               |--LPAREN -> ( [16:73]
|       |       |               |--ELIST -> ELIST [16:74]
|       |       |               `--RPAREN -> ) [16:74]
|       |       |--SEMI -> ; [16:75]
|       |       `--RCURLY -> } [17:4]
|       |--METHOD_DEF -> METHOD_DEF [19:4]
|       |   |--MODIFIERS -> MODIFIERS [19:4]
|       |   |   `--LITERAL_PUBLIC -> public [19:4]
|       |   |--TYPE -> TYPE [19:11]
|       |   |   `--LITERAL_INT -> int [19:11]
|       |   |--IDENT -> compareTo [19:15]
|       |   |--LPAREN -> ( [19:24]
|       |   |--PARAMETERS -> PARAMETERS [19:25]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [19:25]
|       |   |       |--MODIFIERS -> MODIFIERS [19:25]
|       |   |       |--TYPE -> TYPE [19:25]
|       |   |       |   `--IDENT -> Object [19:25]
|       |   |       `--IDENT -> aObject [19:32]
|       |   |--RPAREN -> ) [19:39]
|       |   `--SLIST -> { [20:4]
|       |       |--LITERAL_RETURN -> return [21:8]
|       |       |   |--EXPR -> EXPR [21:15]
|       |       |   |   `--NUM_INT -> 0 [21:15]
|       |       |   `--SEMI -> ; [21:16]
|       |       `--RCURLY -> } [22:4]
|       |--METHOD_DEF -> METHOD_DEF [24:4]
|       |   |--MODIFIERS -> MODIFIERS [24:4]
|       |   |   |--LITERAL_PUBLIC -> public [24:4]
|       |   |   `--LITERAL_STATIC -> static [24:11]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [24:18]
|       |   |   |--GENERIC_START -> < [24:18]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [24:19]
|       |   |   |   `--IDENT -> T [24:19]
|       |   |   `--GENERIC_END -> > [24:20]
|       |   |--TYPE -> TYPE [24:22]
|       |   |   |--IDENT -> Callable [24:22]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:30]
|       |   |       |--GENERIC_START -> < [24:30]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:31]
|       |   |       |   `--IDENT -> T [24:31]
|       |   |       `--GENERIC_END -> > [24:32]
|       |   |--IDENT -> callable [24:34]
|       |   |--LPAREN -> ( [24:42]
|       |   |--PARAMETERS -> PARAMETERS [24:43]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [24:43]
|       |   |   |   |--MODIFIERS -> MODIFIERS [24:43]
|       |   |   |   |--TYPE -> TYPE [24:43]
|       |   |   |   |   `--IDENT -> Runnable [24:43]
|       |   |   |   `--IDENT -> task [24:52]
|       |   |   |--COMMA -> , [24:56]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [24:58]
|       |   |       |--MODIFIERS -> MODIFIERS [24:58]
|       |   |       |--TYPE -> TYPE [24:58]
|       |   |       |   `--IDENT -> T [24:58]
|       |   |       `--IDENT -> result [24:60]
|       |   |--RPAREN -> ) [24:66]
|       |   `--SLIST -> { [25:4]
|       |       |--LITERAL_RETURN -> return [26:8]
|       |       |   |--EXPR -> EXPR [26:15]
|       |       |   |   `--LITERAL_NULL -> null [26:15]
|       |       |   `--SEMI -> ; [26:19]
|       |       `--RCURLY -> } [27:4]
|       |--METHOD_DEF -> METHOD_DEF [29:4]
|       |   |--MODIFIERS -> MODIFIERS [29:4]
|       |   |   |--LITERAL_PUBLIC -> public [29:4]
|       |   |   `--LITERAL_STATIC -> static [29:11]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [29:17]
|       |   |   |--GENERIC_START -> < [29:17]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [29:18]
|       |   |   |   `--IDENT -> T [29:18]
|       |   |   `--GENERIC_END -> > [29:19]
|       |   |--TYPE -> TYPE [29:20]
|       |   |   |--IDENT -> Callable [29:20]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:28]
|       |   |       |--GENERIC_START -> < [29:28]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:29]
|       |   |       |   `--IDENT -> T [29:29]
|       |   |       `--GENERIC_END -> > [29:30]
|       |   |--IDENT -> callable2 [29:32]
|       |   |--LPAREN -> ( [29:41]
|       |   |--PARAMETERS -> PARAMETERS [29:42]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [29:42]
|       |   |   |   |--MODIFIERS -> MODIFIERS [29:42]
|       |   |   |   |--TYPE -> TYPE [29:42]
|       |   |   |   |   `--IDENT -> Runnable [29:42]
|       |   |   |   `--IDENT -> task [29:51]
|       |   |   |--COMMA -> , [29:55]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [29:57]
|       |   |       |--MODIFIERS -> MODIFIERS [29:57]
|       |   |       |--TYPE -> TYPE [29:57]
|       |   |       |   `--IDENT -> T [29:57]
|       |   |       `--IDENT -> result [29:59]
|       |   |--RPAREN -> ) [29:65]
|       |   `--SLIST -> { [30:4]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
|       |       |   |--MODIFIERS -> MODIFIERS [31:8]
|       |       |   |--TYPE -> TYPE [31:8]
|       |       |   |   |--IDENT -> Map [31:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:11]
|       |       |   |       |--GENERIC_START -> < [31:11]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:12]
|       |       |   |       |   |--IDENT -> Class [31:12]
|       |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:17]
|       |       |   |       |       |--GENERIC_START -> < [31:17]
|       |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:18]
|       |       |   |       |       |   `--WILDCARD_TYPE -> ? [31:18]
|       |       |   |       |       `--GENERIC_END -> > [31:19]
|       |       |   |       |--COMMA -> , [31:20]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:22]
|       |       |   |       |   `--IDENT -> Integer [31:22]
|       |       |   |       `--GENERIC_END -> > [31:29]
|       |       |   |--IDENT -> x [31:31]
|       |       |   `--ASSIGN -> = [31:33]
|       |       |       `--EXPR -> EXPR [31:35]
|       |       |           `--LITERAL_NEW -> new [31:35]
|       |       |               |--IDENT -> HashMap [31:39]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:46]
|       |       |               |   |--GENERIC_START -> < [31:46]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:47]
|       |       |               |   |   |--IDENT -> Class [31:47]
|       |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:52]
|       |       |               |   |       |--GENERIC_START -> < [31:52]
|       |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:53]
|       |       |               |   |       |   `--WILDCARD_TYPE -> ? [31:53]
|       |       |               |   |       `--GENERIC_END -> > [31:54]
|       |       |               |   |--COMMA -> , [31:55]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:57]
|       |       |               |   |   `--IDENT -> Integer [31:57]
|       |       |               |   `--GENERIC_END -> > [31:64]
|       |       |               |--LPAREN -> ( [31:65]
|       |       |               |--ELIST -> ELIST [31:66]
|       |       |               `--RPAREN -> ) [31:66]
|       |       |--SEMI -> ; [31:67]
|       |       |--LITERAL_FOR -> for [32:8]
|       |       |   |--LPAREN -> ( [32:12]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [32:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [32:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [32:13]
|       |       |   |   |   |   `--FINAL -> final [32:13]
|       |       |   |   |   |--TYPE -> TYPE [32:22]
|       |       |   |   |   |   `--DOT -> . [32:22]
|       |       |   |   |   |       |--IDENT -> Map [32:19]
|       |       |   |   |   |       |--IDENT -> Entry [32:23]
|       |       |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:28]
|       |       |   |   |   |           |--GENERIC_START -> < [32:28]
|       |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:29]
|       |       |   |   |   |           |   |--IDENT -> Class [32:29]
|       |       |   |   |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:34]
|       |       |   |   |   |           |       |--GENERIC_START -> < [32:34]
|       |       |   |   |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:35]
|       |       |   |   |   |           |       |   `--WILDCARD_TYPE -> ? [32:35]
|       |       |   |   |   |           |       `--GENERIC_END -> > [32:36]
|       |       |   |   |   |           |--COMMA -> , [32:37]
|       |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:39]
|       |       |   |   |   |           |   `--IDENT -> Integer [32:39]
|       |       |   |   |   |           `--GENERIC_END -> > [32:46]
|       |       |   |   |   `--IDENT -> entry [32:48]
|       |       |   |   |--COLON -> : [32:54]
|       |       |   |   `--EXPR -> EXPR [32:66]
|       |       |   |       `--METHOD_CALL -> ( [32:66]
|       |       |   |           |--DOT -> . [32:57]
|       |       |   |           |   |--IDENT -> x [32:56]
|       |       |   |           |   `--IDENT -> entrySet [32:58]
|       |       |   |           |--ELIST -> ELIST [32:67]
|       |       |   |           `--RPAREN -> ) [32:67]
|       |       |   |--RPAREN -> ) [32:68]
|       |       |   `--SLIST -> { [32:70]
|       |       |       |--EXPR -> EXPR [33:26]
|       |       |       |   `--METHOD_CALL -> ( [33:26]
|       |       |       |       |--DOT -> . [33:17]
|       |       |       |       |   |--IDENT -> entry [33:12]
|       |       |       |       |   `--IDENT -> getValue [33:18]
|       |       |       |       |--ELIST -> ELIST [33:27]
|       |       |       |       `--RPAREN -> ) [33:27]
|       |       |       |--SEMI -> ; [33:28]
|       |       |       `--RCURLY -> } [34:8]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [35:8]
|       |       |   |--MODIFIERS -> MODIFIERS [35:8]
|       |       |   |--TYPE -> TYPE [35:8]
|       |       |   |   |--IDENT -> Class [35:8]
|       |       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:13]
|       |       |   |   |   |--GENERIC_START -> < [35:13]
|       |       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:14]
|       |       |   |   |   |   `--WILDCARD_TYPE -> ? [35:14]
|       |       |   |   |   `--GENERIC_END -> > [35:15]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [35:16]
|       |       |   |       `--RBRACK -> ] [35:17]
|       |       |   |--IDENT -> parameterClasses [35:19]
|       |       |   `--ASSIGN -> = [35:36]
|       |       |       `--EXPR -> EXPR [35:38]
|       |       |           `--LITERAL_NEW -> new [35:38]
|       |       |               |--IDENT -> Class [35:42]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:47]
|       |       |               |   |--GENERIC_START -> < [35:47]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:48]
|       |       |               |   |   `--WILDCARD_TYPE -> ? [35:48]
|       |       |               |   `--GENERIC_END -> > [35:49]
|       |       |               `--ARRAY_DECLARATOR -> [ [35:50]
|       |       |                   |--EXPR -> EXPR [35:51]
|       |       |                   |   `--NUM_INT -> 0 [35:51]
|       |       |                   `--RBRACK -> ] [35:52]
|       |       |--SEMI -> ; [35:53]
|       |       |--LITERAL_RETURN -> return [36:8]
|       |       |   |--EXPR -> EXPR [36:15]
|       |       |   |   `--LITERAL_NULL -> null [36:15]
|       |       |   `--SEMI -> ; [36:19]
|       |       `--RCURLY -> } [37:4]
|       |--METHOD_DEF -> METHOD_DEF [38:4]
|       |   |--MODIFIERS -> MODIFIERS [38:4]
|       |   |   `--LITERAL_PUBLIC -> public [38:4]
|       |   |--TYPE -> TYPE [38:11]
|       |   |   `--LITERAL_INT -> int [38:11]
|       |   |--IDENT -> getConstructor [38:15]
|       |   |--LPAREN -> ( [38:29]
|       |   |--PARAMETERS -> PARAMETERS [38:30]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:30]
|       |   |       |--MODIFIERS -> MODIFIERS [38:30]
|       |   |       |--TYPE -> TYPE [38:30]
|       |   |       |   |--IDENT -> Class [38:30]
|       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:35]
|       |   |       |       |--GENERIC_START -> < [38:35]
|       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:36]
|       |   |       |       |   `--WILDCARD_TYPE -> ? [38:36]
|       |   |       |       `--GENERIC_END -> > [38:37]
|       |   |       |--ELLIPSIS -> ... [38:38]
|       |   |       `--IDENT -> parameterTypes [38:42]
|       |   |--RPAREN -> ) [38:56]
|       |   `--SLIST -> { [39:4]
|       |       |--EXPR -> EXPR [40:36]
|       |       |   `--METHOD_CALL -> ( [40:36]
|       |       |       |--DOT -> . [40:19]
|       |       |       |   |--IDENT -> Collections [40:8]
|       |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:20]
|       |       |       |   |   |--GENERIC_START -> < [40:20]
|       |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:21]
|       |       |       |   |   |   `--IDENT -> Object [40:21]
|       |       |       |   |   `--GENERIC_END -> > [40:27]
|       |       |       |   `--IDENT -> emptySet [40:28]
|       |       |       |--ELIST -> ELIST [40:37]
|       |       |       `--RPAREN -> ) [40:37]
|       |       |--SEMI -> ; [40:38]
|       |       |--EXPR -> EXPR [41:38]
|       |       |   `--METHOD_CALL -> ( [41:38]
|       |       |       |--DOT -> . [41:19]
|       |       |       |   |--IDENT -> Collections [41:8]
|       |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [41:21]
|       |       |       |   |   |--GENERIC_START -> < [41:21]
|       |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [41:22]
|       |       |       |   |   |   `--IDENT -> Object [41:22]
|       |       |       |   |   `--GENERIC_END -> > [41:28]
|       |       |       |   `--IDENT -> emptySet [41:30]
|       |       |       |--ELIST -> ELIST [41:39]
|       |       |       `--RPAREN -> ) [41:39]
|       |       |--SEMI -> ; [41:40]
|       |       |--LITERAL_RETURN -> return [42:8]
|       |       |   |--EXPR -> EXPR [42:15]
|       |       |   |   `--NUM_INT -> 666 [42:15]
|       |       |   `--SEMI -> ; [42:18]
|       |       `--RCURLY -> } [43:4]
|       |--CTOR_DEF -> CTOR_DEF [45:4]
|       |   |--MODIFIERS -> MODIFIERS [45:4]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [45:4]
|       |   |   |--GENERIC_START -> < [45:4]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [45:5]
|       |   |   |   `--IDENT -> T [45:5]
|       |   |   `--GENERIC_END -> > [45:6]
|       |   |--IDENT -> InputAntlr4AstRegressionWeirdCtor [45:8]
|       |   |--LPAREN -> ( [45:41]
|       |   |--PARAMETERS -> PARAMETERS [45:42]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [45:42]
|       |   |   |   |--MODIFIERS -> MODIFIERS [45:42]
|       |   |   |   |--TYPE -> TYPE [45:42]
|       |   |   |   |   |--IDENT -> List [45:42]
|       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:46]
|       |   |   |   |       |--GENERIC_START -> < [45:46]
|       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:47]
|       |   |   |   |       |   `--IDENT -> T [45:47]
|       |   |   |   |       `--GENERIC_END -> > [45:48]
|       |   |   |   `--IDENT -> things [45:50]
|       |   |   |--COMMA -> , [45:56]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [45:58]
|       |   |       |--MODIFIERS -> MODIFIERS [45:58]
|       |   |       |--TYPE -> TYPE [45:58]
|       |   |       |   `--LITERAL_INT -> int [45:58]
|       |   |       `--IDENT -> i [45:62]
|       |   |--RPAREN -> ) [45:63]
|       |   `--SLIST -> { [46:4]
|       |       `--RCURLY -> } [47:4]
|       |--CTOR_DEF -> CTOR_DEF [49:4]
|       |   |--MODIFIERS -> MODIFIERS [49:4]
|       |   |   `--LITERAL_PUBLIC -> public [49:4]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [49:11]
|       |   |   |--GENERIC_START -> < [49:11]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [49:12]
|       |   |   |   `--IDENT -> T [49:12]
|       |   |   `--GENERIC_END -> > [49:13]
|       |   |--IDENT -> InputAntlr4AstRegressionWeirdCtor [49:15]
|       |   |--LPAREN -> ( [49:48]
|       |   |--PARAMETERS -> PARAMETERS [49:49]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [49:49]
|       |   |       |--MODIFIERS -> MODIFIERS [49:49]
|       |   |       |--TYPE -> TYPE [49:49]
|       |   |       |   |--IDENT -> List [49:49]
|       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:53]
|       |   |       |       |--GENERIC_START -> < [49:53]
|       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:54]
|       |   |       |       |   `--IDENT -> T [49:54]
|       |   |       |       `--GENERIC_END -> > [49:55]
|       |   |       `--IDENT -> things [49:57]
|       |   |--RPAREN -> ) [49:63]
|       |   `--SLIST -> { [50:4]
|       |       `--RCURLY -> } [51:4]
|       |--INTERFACE_DEF -> INTERFACE_DEF [53:4]
|       |   |--MODIFIERS -> MODIFIERS [53:4]
|       |   |   `--LITERAL_PUBLIC -> public [53:4]
|       |   |--LITERAL_INTERFACE -> interface [53:11]
|       |   |--IDENT -> IntEnum [53:21]
|       |   `--OBJBLOCK -> OBJBLOCK [53:29]
|       |       |--LCURLY -> { [53:29]
|       |       `--RCURLY -> } [54:4]
|       |--CLASS_DEF -> CLASS_DEF [56:4]
|       |   |--MODIFIERS -> MODIFIERS [56:4]
|       |   |   |--LITERAL_PUBLIC -> public [56:4]
|       |   |   `--LITERAL_STATIC -> static [56:11]
|       |   |--LITERAL_CLASS -> class [56:18]
|       |   |--IDENT -> IntEnumValueType [56:24]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [56:40]
|       |   |   |--GENERIC_START -> < [56:40]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [56:41]
|       |   |   |   |--IDENT -> E [56:41]
|       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [56:43]
|       |   |   |       |--IDENT -> Enum [56:51]
|       |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:55]
|       |   |   |       |   |--GENERIC_START -> < [56:55]
|       |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:56]
|       |   |   |       |   |   `--IDENT -> E [56:56]
|       |   |   |       |   `--GENERIC_END -> > [56:57]
|       |   |   |       |--TYPE_EXTENSION_AND -> & [56:59]
|       |   |   |       `--IDENT -> IntEnum [56:61]
|       |   |   `--GENERIC_END -> > [56:68]
|       |   `--OBJBLOCK -> OBJBLOCK [56:70]
|       |       |--LCURLY -> { [56:70]
|       |       `--RCURLY -> } [57:4]
|       |--CLASS_DEF -> CLASS_DEF [59:4]
|       |   |--MODIFIERS -> MODIFIERS [59:4]
|       |   |   |--LITERAL_PUBLIC -> public [59:4]
|       |   |   `--LITERAL_STATIC -> static [59:11]
|       |   |--LITERAL_CLASS -> class [59:18]
|       |   |--IDENT -> IntEnumValueType2 [59:24]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [59:41]
|       |   |   |--GENERIC_START -> < [59:41]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [59:42]
|       |   |   |   |--IDENT -> E [59:42]
|       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [59:44]
|       |   |   |       |--IDENT -> Enum [59:52]
|       |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [59:56]
|       |   |   |       |   |--GENERIC_START -> < [59:56]
|       |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [59:57]
|       |   |   |       |   |   `--IDENT -> E [59:57]
|       |   |   |       |   `--GENERIC_END -> > [59:58]
|       |   |   |       |--TYPE_EXTENSION_AND -> & [59:59]
|       |   |   |       `--IDENT -> IntEnum [59:61]
|       |   |   `--GENERIC_END -> > [59:68]
|       |   `--OBJBLOCK -> OBJBLOCK [59:70]
|       |       |--LCURLY -> { [59:70]
|       |       `--RCURLY -> } [60:4]
|       |--CLASS_DEF -> CLASS_DEF [62:4]
|       |   |--MODIFIERS -> MODIFIERS [62:4]
|       |   |   |--LITERAL_PUBLIC -> public [62:4]
|       |   |   `--LITERAL_STATIC -> static [62:11]
|       |   |--LITERAL_CLASS -> class [62:18]
|       |   |--IDENT -> IntEnumValueType3 [62:24]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [62:41]
|       |   |   |--GENERIC_START -> < [62:41]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [62:42]
|       |   |   |   |--IDENT -> E [62:42]
|       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [62:44]
|       |   |   |       |--IDENT -> Enum [62:52]
|       |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [62:56]
|       |   |   |       |   |--GENERIC_START -> < [62:56]
|       |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [62:57]
|       |   |   |       |   |   `--IDENT -> E [62:57]
|       |   |   |       |   `--GENERIC_END -> > [62:58]
|       |   |   |       |--TYPE_EXTENSION_AND -> & [62:61]
|       |   |   |       `--IDENT -> IntEnum [62:63]
|       |   |   `--GENERIC_END -> > [62:70]
|       |   `--OBJBLOCK -> OBJBLOCK [62:72]
|       |       |--LCURLY -> { [62:72]
|       |       `--RCURLY -> } [63:4]
|       |--CLASS_DEF -> CLASS_DEF [65:4]
|       |   |--MODIFIERS -> MODIFIERS [65:4]
|       |   |   |--LITERAL_PUBLIC -> public [65:4]
|       |   |   `--LITERAL_STATIC -> static [65:11]
|       |   |--LITERAL_CLASS -> class [65:18]
|       |   |--IDENT -> IntEnumValueType4 [65:24]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [65:41]
|       |   |   |--GENERIC_START -> < [65:41]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [65:42]
|       |   |   |   |--IDENT -> T [65:42]
|       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [65:44]
|       |   |   |       |--IDENT -> Comparable [65:52]
|       |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [65:62]
|       |   |   |       |   |--GENERIC_START -> < [65:62]
|       |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [65:63]
|       |   |   |       |   |   |--IDENT -> List [65:63]
|       |   |   |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [65:67]
|       |   |   |       |   |       |--GENERIC_START -> < [65:67]
|       |   |   |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [65:68]
|       |   |   |       |   |       |   `--IDENT -> T [65:68]
|       |   |   |       |   |       `--GENERIC_END -> > [65:69]
|       |   |   |       |   `--GENERIC_END -> > [65:70]
|       |   |   |       |--TYPE_EXTENSION_AND -> & [65:72]
|       |   |   |       `--IDENT -> IntEnum [65:74]
|       |   |   `--GENERIC_END -> > [65:81]
|       |   `--OBJBLOCK -> OBJBLOCK [65:83]
|       |       |--LCURLY -> { [65:83]
|       |       `--RCURLY -> } [66:4]
|       |--METHOD_DEF -> METHOD_DEF [68:4]
|       |   |--MODIFIERS -> MODIFIERS [68:4]
|       |   |   `--LITERAL_PUBLIC -> public [68:4]
|       |   |--TYPE -> TYPE [68:11]
|       |   |   `--LITERAL_VOID -> void [68:11]
|       |   |--IDENT -> beforeAndAfter [68:16]
|       |   |--LPAREN -> ( [68:30]
|       |   |--PARAMETERS -> PARAMETERS [68:31]
|       |   |--RPAREN -> ) [68:31]
|       |   `--SLIST -> { [68:33]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [69:8]
|       |       |   |--MODIFIERS -> MODIFIERS [69:8]
|       |       |   |--TYPE -> TYPE [69:8]
|       |       |   |   |--IDENT -> List [69:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [70:0]
|       |       |   |       |--GENERIC_START -> < [70:0]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [71:0]
|       |       |   |       |   `--IDENT -> Integer [71:0]
|       |       |   |       `--GENERIC_END -> > [71:7]
|       |       |   |--IDENT -> x [71:9]
|       |       |   `--ASSIGN -> = [71:11]
|       |       |       `--EXPR -> EXPR [71:13]
|       |       |           `--LITERAL_NEW -> new [71:13]
|       |       |               |--IDENT -> ArrayList [71:17]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [71:26]
|       |       |               |   |--GENERIC_START -> < [71:26]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [71:27]
|       |       |               |   |   `--IDENT -> Integer [71:27]
|       |       |               |   `--GENERIC_END -> > [72:0]
|       |       |               |--LPAREN -> ( [72:1]
|       |       |               |--ELIST -> ELIST [72:2]
|       |       |               `--RPAREN -> ) [72:2]
|       |       |--SEMI -> ; [72:3]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [73:8]
|       |       |   |--MODIFIERS -> MODIFIERS [73:8]
|       |       |   |--TYPE -> TYPE [73:8]
|       |       |   |   |--IDENT -> List [73:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [74:16]
|       |       |   |       |--GENERIC_START -> < [74:16]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [74:17]
|       |       |   |       |   `--IDENT -> Integer [74:17]
|       |       |   |       `--GENERIC_END -> > [74:24]
|       |       |   |--IDENT -> y [74:26]
|       |       |   `--ASSIGN -> = [74:28]
|       |       |       `--EXPR -> EXPR [74:30]
|       |       |           `--LITERAL_NEW -> new [74:30]
|       |       |               |--IDENT -> ArrayList [74:34]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [74:43]
|       |       |               |   |--GENERIC_START -> < [74:43]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [74:44]
|       |       |               |   |   `--IDENT -> Integer [74:44]
|       |       |               |   `--GENERIC_END -> > [75:8]
|       |       |               |--LPAREN -> ( [75:9]
|       |       |               |--ELIST -> ELIST [75:10]
|       |       |               `--RPAREN -> ) [75:10]
|       |       |--SEMI -> ; [75:11]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [76:8]
|       |       |   |--MODIFIERS -> MODIFIERS [76:8]
|       |       |   |--TYPE -> TYPE [76:8]
|       |       |   |   |--IDENT -> Map [76:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:11]
|       |       |   |       |--GENERIC_START -> < [76:11]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:12]
|       |       |   |       |   |--IDENT -> Class [76:12]
|       |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:17]
|       |       |   |       |       |--GENERIC_START -> < [76:17]
|       |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:18]
|       |       |   |       |       |   `--WILDCARD_TYPE -> ? [76:18]
|       |       |   |       |       `--GENERIC_END -> > [76:19]
|       |       |   |       |--COMMA -> , [76:20]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:22]
|       |       |   |       |   `--IDENT -> Integer [76:22]
|       |       |   |       `--GENERIC_END -> > [76:29]
|       |       |   |--IDENT -> a [76:31]
|       |       |   `--ASSIGN -> = [76:33]
|       |       |       `--EXPR -> EXPR [76:35]
|       |       |           `--LITERAL_NEW -> new [76:35]
|       |       |               |--IDENT -> HashMap [76:39]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:46]
|       |       |               |   |--GENERIC_START -> < [76:46]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:47]
|       |       |               |   |   |--IDENT -> Class [76:47]
|       |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:52]
|       |       |               |   |       |--GENERIC_START -> < [76:52]
|       |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:53]
|       |       |               |   |       |   `--WILDCARD_TYPE -> ? [76:53]
|       |       |               |   |       `--GENERIC_END -> > [76:54]
|       |       |               |   |--COMMA -> , [76:55]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:57]
|       |       |               |   |   `--IDENT -> Integer [76:57]
|       |       |               |   `--GENERIC_END -> > [76:64]
|       |       |               |--LPAREN -> ( [76:65]
|       |       |               |--ELIST -> ELIST [76:66]
|       |       |               `--RPAREN -> ) [76:66]
|       |       |--SEMI -> ; [76:67]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [77:8]
|       |       |   |--MODIFIERS -> MODIFIERS [77:8]
|       |       |   |--TYPE -> TYPE [77:8]
|       |       |   |   |--IDENT -> Map [77:8]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:11]
|       |       |   |       |--GENERIC_START -> < [77:11]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:12]
|       |       |   |       |   |--IDENT -> Class [77:12]
|       |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:17]
|       |       |   |       |       |--GENERIC_START -> < [77:17]
|       |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:18]
|       |       |   |       |       |   `--WILDCARD_TYPE -> ? [77:18]
|       |       |   |       |       `--GENERIC_END -> > [77:19]
|       |       |   |       |--COMMA -> , [77:20]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:22]
|       |       |   |       |   `--IDENT -> Integer [77:22]
|       |       |   |       `--GENERIC_END -> > [77:29]
|       |       |   |--IDENT -> b [77:31]
|       |       |   `--ASSIGN -> = [77:33]
|       |       |       `--EXPR -> EXPR [77:35]
|       |       |           `--TYPECAST -> ( [77:35]
|       |       |               |--TYPE -> TYPE [77:36]
|       |       |               |   |--IDENT -> Map [77:36]
|       |       |               |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:39]
|       |       |               |       |--GENERIC_START -> < [77:39]
|       |       |               |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:40]
|       |       |               |       |   |--IDENT -> Class [77:40]
|       |       |               |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:45]
|       |       |               |       |       |--GENERIC_START -> < [77:45]
|       |       |               |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:46]
|       |       |               |       |       |   `--WILDCARD_TYPE -> ? [77:46]
|       |       |               |       |       `--GENERIC_END -> > [77:47]
|       |       |               |       |--COMMA -> , [77:48]
|       |       |               |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:50]
|       |       |               |       |   `--IDENT -> Integer [77:50]
|       |       |               |       `--GENERIC_END -> > [77:57]
|       |       |               |--RPAREN -> ) [77:58]
|       |       |               `--IDENT -> a [77:60]
|       |       |--SEMI -> ; [77:61]
|       |       `--RCURLY -> } [78:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [79:4]
|       |   |--MODIFIERS -> MODIFIERS [79:4]
|       |   |--TYPE -> TYPE [79:4]
|       |   |   `--IDENT -> Object [79:4]
|       |   |--IDENT -> ok [79:11]
|       |   |--ASSIGN -> = [79:14]
|       |   |   `--EXPR -> EXPR [79:16]
|       |   |       `--LITERAL_NEW -> new [79:16]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [79:20]
|       |   |           |   |--GENERIC_START -> < [79:20]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [79:21]
|       |   |           |   |   `--IDENT -> String [79:21]
|       |   |           |   `--GENERIC_END -> > [79:27]
|       |   |           |--IDENT -> Object [79:28]
|       |   |           |--LPAREN -> ( [79:34]
|       |   |           |--ELIST -> ELIST [79:35]
|       |   |           `--RPAREN -> ) [79:35]
|       |   `--SEMI -> ; [79:36]
|       |--VARIABLE_DEF -> VARIABLE_DEF [80:4]
|       |   |--MODIFIERS -> MODIFIERS [80:4]
|       |   |--TYPE -> TYPE [80:4]
|       |   |   `--IDENT -> Object [80:4]
|       |   |--IDENT -> notOkStart [80:11]
|       |   |--ASSIGN -> = [80:22]
|       |   |   `--EXPR -> EXPR [80:24]
|       |   |       `--LITERAL_NEW -> new [80:24]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [80:27]
|       |   |           |   |--GENERIC_START -> < [80:27]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [80:28]
|       |   |           |   |   `--IDENT -> String [80:28]
|       |   |           |   `--GENERIC_END -> > [80:34]
|       |   |           |--IDENT -> Object [80:35]
|       |   |           |--LPAREN -> ( [80:41]
|       |   |           |--ELIST -> ELIST [80:42]
|       |   |           `--RPAREN -> ) [80:42]
|       |   `--SEMI -> ; [80:43]
|       |--VARIABLE_DEF -> VARIABLE_DEF [81:4]
|       |   |--MODIFIERS -> MODIFIERS [81:4]
|       |   |--TYPE -> TYPE [81:4]
|       |   |   `--IDENT -> Object [81:4]
|       |   |--IDENT -> notOkEnd [81:11]
|       |   |--ASSIGN -> = [81:20]
|       |   |   `--EXPR -> EXPR [81:22]
|       |   |       `--LITERAL_NEW -> new [81:22]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [81:26]
|       |   |           |   |--GENERIC_START -> < [81:26]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [81:27]
|       |   |           |   |   `--IDENT -> String [81:27]
|       |   |           |   `--GENERIC_END -> > [81:33]
|       |   |           |--IDENT -> Object [81:35]
|       |   |           |--LPAREN -> ( [81:41]
|       |   |           |--ELIST -> ELIST [81:42]
|       |   |           `--RPAREN -> ) [81:42]
|       |   `--SEMI -> ; [81:43]
|       |--VARIABLE_DEF -> VARIABLE_DEF [82:4]
|       |   |--MODIFIERS -> MODIFIERS [82:4]
|       |   |--TYPE -> TYPE [82:4]
|       |   |   `--IDENT -> Object [82:4]
|       |   |--IDENT -> notOkStartAndEnd [82:11]
|       |   |--ASSIGN -> = [82:28]
|       |   |   `--EXPR -> EXPR [82:30]
|       |   |       `--LITERAL_NEW -> new [82:30]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [82:33]
|       |   |           |   |--GENERIC_START -> < [82:33]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [82:34]
|       |   |           |   |   `--IDENT -> String [82:34]
|       |   |           |   `--GENERIC_END -> > [82:40]
|       |   |           |--IDENT -> Object [82:42]
|       |   |           |--LPAREN -> ( [82:48]
|       |   |           |--ELIST -> ELIST [82:49]
|       |   |           `--RPAREN -> ) [82:49]
|       |   `--SEMI -> ; [82:50]
|       |--VARIABLE_DEF -> VARIABLE_DEF [83:4]
|       |   |--MODIFIERS -> MODIFIERS [83:4]
|       |   |--TYPE -> TYPE [83:4]
|       |   |   `--IDENT -> Object [83:4]
|       |   |--IDENT -> okWithPackage [83:11]
|       |   |--ASSIGN -> = [83:25]
|       |   |   `--EXPR -> EXPR [83:27]
|       |   |       `--LITERAL_NEW -> new [83:27]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [83:31]
|       |   |           |   |--GENERIC_START -> < [83:31]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [83:32]
|       |   |           |   |   `--IDENT -> String [83:32]
|       |   |           |   `--GENERIC_END -> > [83:38]
|       |   |           |--DOT -> . [83:48]
|       |   |           |   |--DOT -> . [83:43]
|       |   |           |   |   |--IDENT -> java [83:39]
|       |   |           |   |   `--IDENT -> lang [83:44]
|       |   |           |   `--IDENT -> Object [83:49]
|       |   |           |--LPAREN -> ( [83:55]
|       |   |           |--ELIST -> ELIST [83:56]
|       |   |           `--RPAREN -> ) [83:56]
|       |   `--SEMI -> ; [83:57]
|       |--VARIABLE_DEF -> VARIABLE_DEF [84:4]
|       |   |--MODIFIERS -> MODIFIERS [84:4]
|       |   |--TYPE -> TYPE [84:4]
|       |   |   `--IDENT -> Object [84:4]
|       |   |--IDENT -> ok2 [84:11]
|       |   |--ASSIGN -> = [84:15]
|       |   |   `--EXPR -> EXPR [84:17]
|       |   |       `--LITERAL_NEW -> new [84:17]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [84:21]
|       |   |           |   |--GENERIC_START -> < [84:21]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [84:22]
|       |   |           |   |   `--IDENT -> String [84:22]
|       |   |           |   `--GENERIC_END -> > [84:28]
|       |   |           |--DOT -> . [84:34]
|       |   |           |   |--IDENT -> Outer [84:29]
|       |   |           |   `--IDENT -> Inner [84:35]
|       |   |           |--LPAREN -> ( [84:40]
|       |   |           |--ELIST -> ELIST [84:41]
|       |   |           `--RPAREN -> ) [84:41]
|       |   `--SEMI -> ; [84:42]
|       |--VARIABLE_DEF -> VARIABLE_DEF [85:4]
|       |   |--MODIFIERS -> MODIFIERS [85:4]
|       |   |--TYPE -> TYPE [85:4]
|       |   |   `--IDENT -> Object [85:4]
|       |   |--IDENT -> notOkStart2 [85:11]
|       |   |--ASSIGN -> = [85:23]
|       |   |   `--EXPR -> EXPR [85:25]
|       |   |       `--LITERAL_NEW -> new [85:25]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [85:28]
|       |   |           |   |--GENERIC_START -> < [85:28]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [85:29]
|       |   |           |   |   `--IDENT -> String [85:29]
|       |   |           |   `--GENERIC_END -> > [85:35]
|       |   |           |--DOT -> . [85:41]
|       |   |           |   |--IDENT -> Outer [85:36]
|       |   |           |   `--IDENT -> Inner [85:42]
|       |   |           |--LPAREN -> ( [85:47]
|       |   |           |--ELIST -> ELIST [85:48]
|       |   |           `--RPAREN -> ) [85:48]
|       |   `--SEMI -> ; [85:49]
|       |--VARIABLE_DEF -> VARIABLE_DEF [86:4]
|       |   |--MODIFIERS -> MODIFIERS [86:4]
|       |   |--TYPE -> TYPE [86:4]
|       |   |   `--IDENT -> Object [86:4]
|       |   |--IDENT -> notOkEnd2 [86:11]
|       |   |--ASSIGN -> = [86:21]
|       |   |   `--EXPR -> EXPR [86:23]
|       |   |       `--LITERAL_NEW -> new [86:23]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [86:27]
|       |   |           |   |--GENERIC_START -> < [86:27]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [86:28]
|       |   |           |   |   `--IDENT -> String [86:28]
|       |   |           |   `--GENERIC_END -> > [86:34]
|       |   |           |--DOT -> . [86:41]
|       |   |           |   |--IDENT -> Outer [86:36]
|       |   |           |   `--IDENT -> Inner [86:42]
|       |   |           |--LPAREN -> ( [86:47]
|       |   |           |--ELIST -> ELIST [86:48]
|       |   |           `--RPAREN -> ) [86:48]
|       |   `--SEMI -> ; [86:49]
|       |--VARIABLE_DEF -> VARIABLE_DEF [87:4]
|       |   |--MODIFIERS -> MODIFIERS [87:4]
|       |   |--TYPE -> TYPE [87:4]
|       |   |   `--IDENT -> Object [87:4]
|       |   |--IDENT -> notOkStartAndEnd2 [87:11]
|       |   |--ASSIGN -> = [87:29]
|       |   |   `--EXPR -> EXPR [87:31]
|       |   |       `--LITERAL_NEW -> new [87:31]
|       |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [87:34]
|       |   |           |   |--GENERIC_START -> < [87:34]
|       |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [87:35]
|       |   |           |   |   `--IDENT -> String [87:35]
|       |   |           |   `--GENERIC_END -> > [87:41]
|       |   |           |--DOT -> . [87:48]
|       |   |           |   |--IDENT -> Outer [87:43]
|       |   |           |   `--IDENT -> Inner [87:49]
|       |   |           |--LPAREN -> ( [87:54]
|       |   |           |--ELIST -> ELIST [87:55]
|       |   |           `--RPAREN -> ) [87:55]
|       |   `--SEMI -> ; [87:56]
|       `--RCURLY -> } [88:0]
|--INTERFACE_DEF -> INTERFACE_DEF [89:0]
|   |--MODIFIERS -> MODIFIERS [89:0]
|   |--LITERAL_INTERFACE -> interface [89:0]
|   |--IDENT -> SupplierFunction [89:10]
|   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [89:26]
|   |   |--GENERIC_START -> < [89:26]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [89:27]
|   |   |   `--IDENT -> T [89:27]
|   |   `--GENERIC_END -> > [89:28]
|   |--EXTENDS_CLAUSE -> extends [89:30]
|   |   |--IDENT -> Map [89:38]
|   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:41]
|   |       |--GENERIC_START -> < [89:41]
|   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:42]
|   |       |   |--IDENT -> List [89:42]
|   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:46]
|   |       |       |--GENERIC_START -> < [89:46]
|   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:47]
|   |       |       |   `--IDENT -> T [89:47]
|   |       |       `--GENERIC_END -> > [89:48]
|   |       |--COMMA -> , [89:49]
|   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:51]
|   |       |   `--IDENT -> T [89:51]
|   |       `--GENERIC_END -> > [89:52]
|   `--OBJBLOCK -> OBJBLOCK [89:54]
|       |--LCURLY -> { [89:54]
|       `--RCURLY -> } [89:55]
`--CLASS_DEF -> CLASS_DEF [91:0]
    |--MODIFIERS -> MODIFIERS [91:0]
    |--LITERAL_CLASS -> class [91:0]
    |--IDENT -> Outer [91:6]
    `--OBJBLOCK -> OBJBLOCK [91:12]
        |--LCURLY -> { [91:12]
        |--CLASS_DEF -> CLASS_DEF [92:4]
        |   |--MODIFIERS -> MODIFIERS [92:4]
        |   |   `--LITERAL_STATIC -> static [92:4]
        |   |--LITERAL_CLASS -> class [92:11]
        |   |--IDENT -> Inner [92:17]
        |   `--OBJBLOCK -> OBJBLOCK [92:23]
        |       |--LCURLY -> { [92:23]
        |       `--RCURLY -> } [92:24]
        `--RCURLY -> } [93:0]
