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