COMPILATION_UNIT -> COMPILATION_UNIT [3:1]
|--SINGLE_LINE_COMMENT -> // [1:1]
|   `--COMMENT_CONTENT ->  non-compiled with eclipse: Type arguments are not allowed\n [1:3]
|--SINGLE_LINE_COMMENT -> // [2:1]
|   `--COMMENT_CONTENT ->  non-compiled with javac: contains specially crafted set of imports that requires classpath\n [2:3]
|--PACKAGE_DEF -> package [3:1]
|   |--ANNOTATIONS -> ANNOTATIONS [3:48]
|   |--DOT -> . [3:48]
|   |   |--DOT -> . [3:40]
|   |   |   |--DOT -> . [3:29]
|   |   |   |   |--DOT -> . [3:23]
|   |   |   |   |   |--DOT -> . [3:12]
|   |   |   |   |   |   |--IDENT -> com [3:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [3:13]
|   |   |   |   |   `--IDENT -> tools [3:24]
|   |   |   |   `--IDENT -> checkstyle [3:30]
|   |   |   `--IDENT -> grammar [3:41]
|   |   `--IDENT -> antlr4 [3:49]
|   `--SEMI -> ; [3:55]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:15]
|   |   |--DOT -> . [5:12]
|   |   |   |--IDENT -> java [5:8]
|   |   |   `--IDENT -> io [5:13]
|   |   `--IDENT -> Serializable [5:16]
|   `--SEMI -> ; [5:28]
|--IMPORT -> import [6:1]
|   |--DOT -> . [6:17]
|   |   |--DOT -> . [6:12]
|   |   |   |--IDENT -> java [6:8]
|   |   |   `--IDENT -> util [6:13]
|   |   `--IDENT -> Collection [6:18]
|   `--SEMI -> ; [6:28]
|--IMPORT -> import [7:1]
|   |--DOT -> . [7:17]
|   |   |--DOT -> . [7:12]
|   |   |   |--IDENT -> java [7:8]
|   |   |   `--IDENT -> util [7:13]
|   |   `--IDENT -> Collections [7:18]
|   `--SEMI -> ; [7:29]
|--IMPORT -> import [8:1]
|   |--DOT -> . [8:17]
|   |   |--DOT -> . [8:12]
|   |   |   |--IDENT -> java [8:8]
|   |   |   `--IDENT -> util [8:13]
|   |   `--IDENT -> Iterator [8:18]
|   `--SEMI -> ; [8:26]
|--IMPORT -> import [9:1]
|   |--DOT -> . [9:17]
|   |   |--DOT -> . [9:12]
|   |   |   |--IDENT -> java [9:8]
|   |   |   `--IDENT -> util [9:13]
|   |   `--IDENT -> List [9:18]
|   `--SEMI -> ; [9:22]
|--IMPORT -> import [10:1]
|   |--DOT -> . [10:17]
|   |   |--DOT -> . [10:12]
|   |   |   |--IDENT -> java [10:8]
|   |   |   `--IDENT -> util [10:13]
|   |   `--IDENT -> ListIterator [10:18]
|   `--SEMI -> ; [10:30]
|--IMPORT -> import [11:1]
|   |--DOT -> . [11:26]
|   |   |--DOT -> . [11:17]
|   |   |   |--DOT -> . [11:12]
|   |   |   |   |--IDENT -> java [11:8]
|   |   |   |   `--IDENT -> util [11:13]
|   |   |   `--IDENT -> function [11:18]
|   |   `--IDENT -> IntFunction [11:27]
|   `--SEMI -> ; [11:38]
|--IMPORT -> import [13:1]
|   |--DOT -> . [13:27]
|   |   |--DOT -> . [13:21]
|   |   |   |--DOT -> . [13:15]
|   |   |   |   |--DOT -> . [13:11]
|   |   |   |   |   |--IDENT -> com [13:8]
|   |   |   |   |   `--IDENT -> sun [13:12]
|   |   |   |   `--IDENT -> tools [13:16]
|   |   |   `--IDENT -> javac [13:22]
|   |   `--IDENT -> Main [13:28]
|   `--SEMI -> ; [13:32]
|--CLASS_DEF -> CLASS_DEF [15:1]
|   |--MODIFIERS -> MODIFIERS [15:1]
|   |   `--LITERAL_PUBLIC -> public [15:1]
|   |--LITERAL_CLASS -> class [15:8]
|   |--IDENT -> InputAntlr4AstRegressionUncommon [15:14]
|   |--IMPLEMENTS_CLAUSE -> implements [16:9]
|   |   `--IDENT -> MyInterface [16:20]
|   `--OBJBLOCK -> OBJBLOCK [16:32]
|       |--LCURLY -> { [16:32]
|       |--VARIABLE_DEF -> VARIABLE_DEF [17:5]
|       |   |--MODIFIERS -> MODIFIERS [17:5]
|       |   |--TYPE -> TYPE [17:5]
|       |   |   |--LITERAL_INT -> int [17:5]
|       |   |   `--ARRAY_DECLARATOR -> [ [17:10]
|       |   |       `--RBRACK -> ] [17:11]
|       |   |--IDENT -> x [17:9]
|       |   `--SEMI -> ; [17:24]
|       |--COMMA -> , [17:12]
|       |--VARIABLE_DEF -> VARIABLE_DEF [17:5]
|       |   |--MODIFIERS -> MODIFIERS [17:5]
|       |   |--TYPE -> TYPE [17:5]
|       |   |   |--LITERAL_INT -> int [17:5]
|       |   |   `--ARRAY_DECLARATOR -> [ [17:15]
|       |   |       `--RBRACK -> ] [17:16]
|       |   `--IDENT -> y [17:14]
|       |--COMMA -> , [17:17]
|       |--VARIABLE_DEF -> VARIABLE_DEF [17:5]
|       |   |--MODIFIERS -> MODIFIERS [17:5]
|       |   |--TYPE -> TYPE [17:5]
|       |   |   |--LITERAL_INT -> int [17:5]
|       |   |   |--ARRAY_DECLARATOR -> [ [17:20]
|       |   |   |   `--RBRACK -> ] [17:21]
|       |   |   `--ARRAY_DECLARATOR -> [ [17:22]
|       |   |       `--RBRACK -> ] [17:23]
|       |   `--IDENT -> z [17:19]
|       |--METHOD_DEF -> METHOD_DEF [19:5]
|       |   |--MODIFIERS -> MODIFIERS [19:5]
|       |   |   `--LITERAL_PUBLIC -> public [19:5]
|       |   |--TYPE -> TYPE [19:12]
|       |   |   |--IDENT -> Double [19:12]
|       |   |   `--ARRAY_DECLARATOR -> [ [19:28]
|       |   |       `--RBRACK -> ] [19:29]
|       |   |--IDENT -> method1 [19:19]
|       |   |--LPAREN -> ( [19:26]
|       |   |--PARAMETERS -> PARAMETERS [19:27]
|       |   |--RPAREN -> ) [19:27]
|       |   `--SLIST -> { [19:31]
|       |       |--LITERAL_RETURN -> return [20:9]
|       |       |   |--EXPR -> EXPR [20:16]
|       |       |   |   `--LITERAL_NULL -> null [20:16]
|       |       |   `--SEMI -> ; [20:20]
|       |       `--RCURLY -> } [21:5]
|       |--METHOD_DEF -> METHOD_DEF [23:5]
|       |   |--MODIFIERS -> MODIFIERS [23:5]
|       |   |   `--LITERAL_PROTECTED -> protected [23:5]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [23:15]
|       |   |   |--GENERIC_START -> < [23:15]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:16]
|       |   |   |   `--IDENT -> B [23:16]
|       |   |   |--COMMA -> , [23:17]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:19]
|       |   |   |   `--IDENT -> Z [23:19]
|       |   |   |--COMMA -> , [23:20]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:22]
|       |   |   |   `--IDENT -> A [23:22]
|       |   |   `--GENERIC_END -> > [23:23]
|       |   |--TYPE -> TYPE [23:35]
|       |   |   `--DOT -> . [23:35]
|       |   |       |--IDENT -> OtherClass [23:25]
|       |   |       |--IDENT -> Q [23:36]
|       |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:37]
|       |   |           |--GENERIC_START -> < [23:37]
|       |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:38]
|       |   |           |   `--IDENT -> A [23:38]
|       |   |           |--COMMA -> , [23:39]
|       |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:40]
|       |   |           |   `--IDENT -> B [23:40]
|       |   |           |--COMMA -> , [23:41]
|       |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:42]
|       |   |           |   `--IDENT -> Z [23:42]
|       |   |           `--GENERIC_END -> > [23:43]
|       |   |--IDENT -> m [23:45]
|       |   |--LPAREN -> ( [23:46]
|       |   |--PARAMETERS -> PARAMETERS [23:47]
|       |   |--RPAREN -> ) [23:47]
|       |   `--SLIST -> { [23:49]
|       |       |--LITERAL_RETURN -> return [24:9]
|       |       |   |--EXPR -> EXPR [24:16]
|       |       |   |   `--LITERAL_NULL -> null [24:16]
|       |       |   `--SEMI -> ; [24:20]
|       |       `--RCURLY -> } [25:5]
|       `--RCURLY -> } [26:1]
|--INTERFACE_DEF -> INTERFACE_DEF [28:1]
|   |--MODIFIERS -> MODIFIERS [28:1]
|   |--LITERAL_INTERFACE -> interface [28:1]
|   |--IDENT -> MyInterface [28:11]
|   `--OBJBLOCK -> OBJBLOCK [28:23]
|       |--LCURLY -> { [28:23]
|       |--METHOD_DEF -> METHOD_DEF [29:5]
|       |   |--MODIFIERS -> MODIFIERS [29:5]
|       |   |--TYPE -> TYPE [29:5]
|       |   |   |--IDENT -> Double [29:5]
|       |   |   `--ARRAY_DECLARATOR -> [ [29:21]
|       |   |       `--RBRACK -> ] [29:22]
|       |   |--IDENT -> method1 [29:12]
|       |   |--LPAREN -> ( [29:19]
|       |   |--PARAMETERS -> PARAMETERS [29:20]
|       |   |--RPAREN -> ) [29:20]
|       |   `--SEMI -> ; [29:23]
|       `--RCURLY -> } [30:1]
|--CLASS_DEF -> CLASS_DEF [32:1]
|   |--MODIFIERS -> MODIFIERS [32:1]
|   |--LITERAL_CLASS -> class [32:1]
|   |--IDENT -> OtherClass [32:7]
|   |--EXTENDS_CLAUSE -> extends [32:18]
|   |   `--IDENT -> InputAntlr4AstRegressionUncommon [32:26]
|   `--OBJBLOCK -> OBJBLOCK [32:59]
|       |--LCURLY -> { [32:59]
|       |--CTOR_DEF -> CTOR_DEF [33:5]
|       |   |--MODIFIERS -> MODIFIERS [33:5]
|       |   |--IDENT -> OtherClass [33:5]
|       |   |--LPAREN -> ( [33:16]
|       |   |--PARAMETERS -> PARAMETERS [33:17]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [33:17]
|       |   |       |--MODIFIERS -> MODIFIERS [33:17]
|       |   |       |--TYPE -> TYPE [33:17]
|       |   |       |   `--LITERAL_INT -> int [33:17]
|       |   |       `--IDENT -> z [33:21]
|       |   |--RPAREN -> ) [33:22]
|       |   `--SLIST -> { [33:23]
|       |       |--SUPER_CTOR_CALL -> super [34:9]
|       |       |   |--LPAREN -> ( [34:14]
|       |       |   |--ELIST -> ELIST [34:15]
|       |       |   |--RPAREN -> ) [34:15]
|       |       |   `--SEMI -> ; [34:16]
|       |       `--RCURLY -> } [35:5]
|       |--CLASS_DEF -> CLASS_DEF [36:5]
|       |   |--MODIFIERS -> MODIFIERS [36:5]
|       |   |--LITERAL_CLASS -> class [36:5]
|       |   |--IDENT -> Q [36:11]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [36:12]
|       |   |   |--GENERIC_START -> < [36:12]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:13]
|       |   |   |   `--IDENT -> A [36:13]
|       |   |   |--COMMA -> , [36:14]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:16]
|       |   |   |   `--IDENT -> B [36:16]
|       |   |   |--COMMA -> , [36:17]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:19]
|       |   |   |   `--IDENT -> Z [36:19]
|       |   |   `--GENERIC_END -> > [36:20]
|       |   `--OBJBLOCK -> OBJBLOCK [36:21]
|       |       |--LCURLY -> { [36:21]
|       |       `--RCURLY -> } [36:22]
|       |--SEMI -> ; [38:5]
|       |--METHOD_DEF -> METHOD_DEF [39:5]
|       |   |--MODIFIERS -> MODIFIERS [39:5]
|       |   |   `--LITERAL_PUBLIC -> public [39:5]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [39:12]
|       |   |   |--GENERIC_START -> < [39:12]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [39:13]
|       |   |   |   `--IDENT -> Z [39:13]
|       |   |   |--COMMA -> , [39:14]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [39:16]
|       |   |   |   `--IDENT -> B [39:16]
|       |   |   |--COMMA -> , [39:17]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [39:19]
|       |   |   |   `--IDENT -> A [39:19]
|       |   |   `--GENERIC_END -> > [39:20]
|       |   |--TYPE -> TYPE [39:22]
|       |   |   |--IDENT -> Q [39:22]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:23]
|       |   |       |--GENERIC_START -> < [39:23]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:24]
|       |   |       |   `--IDENT -> A [39:24]
|       |   |       |--COMMA -> , [39:25]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:27]
|       |   |       |   `--IDENT -> Z [39:27]
|       |   |       |--COMMA -> , [39:28]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:30]
|       |   |       |   `--IDENT -> B [39:30]
|       |   |       `--GENERIC_END -> > [39:31]
|       |   |--IDENT -> m [39:33]
|       |   |--LPAREN -> ( [39:34]
|       |   |--PARAMETERS -> PARAMETERS [39:35]
|       |   |--RPAREN -> ) [39:35]
|       |   `--SLIST -> { [39:37]
|       |       |--LITERAL_RETURN -> return [39:39]
|       |       |   |--EXPR -> EXPR [39:46]
|       |       |   |   `--LITERAL_NULL -> null [39:46]
|       |       |   `--SEMI -> ; [39:50]
|       |       `--RCURLY -> } [39:51]
|       |--CTOR_DEF -> CTOR_DEF [41:5]
|       |   |--MODIFIERS -> MODIFIERS [41:5]
|       |   |--IDENT -> OtherClass [41:5]
|       |   |--LPAREN -> ( [41:16]
|       |   |--PARAMETERS -> PARAMETERS [41:17]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [41:17]
|       |   |   |   |--MODIFIERS -> MODIFIERS [41:17]
|       |   |   |   |--TYPE -> TYPE [41:17]
|       |   |   |   |   `--LITERAL_INT -> int [41:17]
|       |   |   |   `--IDENT -> z [41:21]
|       |   |   |--COMMA -> , [41:22]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [41:24]
|       |   |       |--MODIFIERS -> MODIFIERS [41:24]
|       |   |       |--TYPE -> TYPE [41:24]
|       |   |       |   `--IDENT -> String [41:24]
|       |   |       `--IDENT -> s [41:31]
|       |   |--RPAREN -> ) [41:32]
|       |   `--SLIST -> { [41:33]
|       |       |--EXPR -> EXPR [42:9]
|       |       |   `--LITERAL_NEW -> new [42:9]
|       |       |       |--IDENT -> OtherClass [42:13]
|       |       |       |--LPAREN -> ( [42:23]
|       |       |       |--ELIST -> ELIST [42:24]
|       |       |       |   `--EXPR -> EXPR [42:24]
|       |       |       |       `--NUM_INT -> 2 [42:24]
|       |       |       `--RPAREN -> ) [42:25]
|       |       |--SEMI -> ; [42:26]
|       |       `--RCURLY -> } [43:5]
|       |--CLASS_DEF -> CLASS_DEF [45:5]
|       |   |--MODIFIERS -> MODIFIERS [45:5]
|       |   |--LITERAL_CLASS -> class [45:5]
|       |   |--IDENT -> Inner [45:11]
|       |   `--OBJBLOCK -> OBJBLOCK [45:17]
|       |       |--LCURLY -> { [45:17]
|       |       |--CTOR_DEF -> CTOR_DEF [46:9]
|       |       |   |--MODIFIERS -> MODIFIERS [46:9]
|       |       |   |--IDENT -> Inner [46:9]
|       |       |   |--LPAREN -> ( [46:14]
|       |       |   |--PARAMETERS -> PARAMETERS [46:15]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [46:15]
|       |       |   |       |--MODIFIERS -> MODIFIERS [46:15]
|       |       |   |       |--TYPE -> TYPE [46:15]
|       |       |   |       |   `--LITERAL_INT -> int [46:15]
|       |       |   |       `--IDENT -> x [46:19]
|       |       |   |--RPAREN -> ) [46:20]
|       |       |   `--SLIST -> { [46:22]
|       |       |       `--RCURLY -> } [46:23]
|       |       |--CTOR_DEF -> CTOR_DEF [47:9]
|       |       |   |--MODIFIERS -> MODIFIERS [47:9]
|       |       |   |--IDENT -> Inner [47:9]
|       |       |   |--LPAREN -> ( [47:14]
|       |       |   |--PARAMETERS -> PARAMETERS [47:15]
|       |       |   |--RPAREN -> ) [47:15]
|       |       |   `--SLIST -> { [47:17]
|       |       |       |--CTOR_CALL -> this [48:13]
|       |       |       |   |--LPAREN -> ( [48:17]
|       |       |       |   |--ELIST -> ELIST [48:18]
|       |       |       |   |   `--EXPR -> EXPR [48:18]
|       |       |       |   |       `--NUM_INT -> 2 [48:18]
|       |       |       |   |--RPAREN -> ) [48:19]
|       |       |       |   `--SEMI -> ; [48:20]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [49:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [49:13]
|       |       |       |   |--TYPE -> TYPE [49:13]
|       |       |       |   |   |--IDENT -> List [49:13]
|       |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:17]
|       |       |       |   |       |--GENERIC_START -> < [49:17]
|       |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:18]
|       |       |       |   |       |   `--IDENT -> String [49:18]
|       |       |       |   |       `--GENERIC_END -> > [49:24]
|       |       |       |   |--IDENT -> list [49:26]
|       |       |       |   `--ASSIGN -> = [49:31]
|       |       |       |       `--EXPR -> EXPR [49:33]
|       |       |       |           `--LITERAL_NEW -> new [49:33]
|       |       |       |               |--IDENT -> List [49:37]
|       |       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:41]
|       |       |       |               |   |--GENERIC_START -> < [49:41]
|       |       |       |               |   `--GENERIC_END -> > [49:42]
|       |       |       |               |--LPAREN -> ( [49:43]
|       |       |       |               |--ELIST -> ELIST [49:44]
|       |       |       |               |--RPAREN -> ) [49:44]
|       |       |       |               `--OBJBLOCK -> OBJBLOCK [49:46]
|       |       |       |                   |--LCURLY -> { [49:46]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [50:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [50:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [50:17]
|       |       |       |                   |   |   |   |--AT -> @ [50:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [50:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [51:17]
|       |       |       |                   |   |--TYPE -> TYPE [51:24]
|       |       |       |                   |   |   `--LITERAL_INT -> int [51:24]
|       |       |       |                   |   |--IDENT -> size [51:28]
|       |       |       |                   |   |--LPAREN -> ( [51:32]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [51:33]
|       |       |       |                   |   |--RPAREN -> ) [51:33]
|       |       |       |                   |   `--SLIST -> { [51:35]
|       |       |       |                   |       |--LITERAL_RETURN -> return [52:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [52:28]
|       |       |       |                   |       |   |   `--NUM_INT -> 0 [52:28]
|       |       |       |                   |       |   `--SEMI -> ; [52:29]
|       |       |       |                   |       `--RCURLY -> } [53:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [55:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [55:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [55:17]
|       |       |       |                   |   |   |   |--AT -> @ [55:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [55:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [56:17]
|       |       |       |                   |   |--TYPE -> TYPE [56:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [56:24]
|       |       |       |                   |   |--IDENT -> isEmpty [56:32]
|       |       |       |                   |   |--LPAREN -> ( [56:39]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [56:40]
|       |       |       |                   |   |--RPAREN -> ) [56:40]
|       |       |       |                   |   `--SLIST -> { [56:42]
|       |       |       |                   |       |--LITERAL_RETURN -> return [57:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [57:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [57:28]
|       |       |       |                   |       |   `--SEMI -> ; [57:33]
|       |       |       |                   |       `--RCURLY -> } [58:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [60:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [60:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [60:17]
|       |       |       |                   |   |   |   |--AT -> @ [60:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [60:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [61:17]
|       |       |       |                   |   |--TYPE -> TYPE [61:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [61:24]
|       |       |       |                   |   |--IDENT -> contains [61:32]
|       |       |       |                   |   |--LPAREN -> ( [61:40]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [61:41]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [61:41]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [61:41]
|       |       |       |                   |   |       |--TYPE -> TYPE [61:41]
|       |       |       |                   |   |       |   `--IDENT -> Object [61:41]
|       |       |       |                   |   |       `--IDENT -> o [61:48]
|       |       |       |                   |   |--RPAREN -> ) [61:49]
|       |       |       |                   |   `--SLIST -> { [61:51]
|       |       |       |                   |       |--LITERAL_RETURN -> return [62:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [62:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [62:28]
|       |       |       |                   |       |   `--SEMI -> ; [62:33]
|       |       |       |                   |       `--RCURLY -> } [63:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [65:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [65:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [65:17]
|       |       |       |                   |   |   |   |--AT -> @ [65:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [65:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [66:17]
|       |       |       |                   |   |--TYPE -> TYPE [66:24]
|       |       |       |                   |   |   |--IDENT -> Iterator [66:24]
|       |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:32]
|       |       |       |                   |   |       |--GENERIC_START -> < [66:32]
|       |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:33]
|       |       |       |                   |   |       |   `--IDENT -> String [66:33]
|       |       |       |                   |   |       `--GENERIC_END -> > [66:39]
|       |       |       |                   |   |--IDENT -> iterator [66:41]
|       |       |       |                   |   |--LPAREN -> ( [66:49]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [66:50]
|       |       |       |                   |   |--RPAREN -> ) [66:50]
|       |       |       |                   |   `--SLIST -> { [66:52]
|       |       |       |                   |       |--LITERAL_RETURN -> return [67:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [67:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [67:28]
|       |       |       |                   |       |   `--SEMI -> ; [67:32]
|       |       |       |                   |       `--RCURLY -> } [68:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [70:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [70:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [70:17]
|       |       |       |                   |   |   |   |--AT -> @ [70:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [70:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [71:17]
|       |       |       |                   |   |--TYPE -> TYPE [71:24]
|       |       |       |                   |   |   |--IDENT -> Object [71:24]
|       |       |       |                   |   |   `--ARRAY_DECLARATOR -> [ [71:30]
|       |       |       |                   |   |       `--RBRACK -> ] [71:31]
|       |       |       |                   |   |--IDENT -> toArray [71:33]
|       |       |       |                   |   |--LPAREN -> ( [71:40]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [71:41]
|       |       |       |                   |   |--RPAREN -> ) [71:41]
|       |       |       |                   |   `--SLIST -> { [71:43]
|       |       |       |                   |       |--LITERAL_RETURN -> return [72:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [72:28]
|       |       |       |                   |       |   |   `--LITERAL_NEW -> new [72:28]
|       |       |       |                   |       |   |       |--IDENT -> Object [72:32]
|       |       |       |                   |       |   |       `--ARRAY_DECLARATOR -> [ [72:38]
|       |       |       |                   |       |   |           |--EXPR -> EXPR [72:39]
|       |       |       |                   |       |   |           |   `--NUM_INT -> 0 [72:39]
|       |       |       |                   |       |   |           `--RBRACK -> ] [72:40]
|       |       |       |                   |       |   `--SEMI -> ; [72:41]
|       |       |       |                   |       `--RCURLY -> } [73:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [75:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [75:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [75:17]
|       |       |       |                   |   |   |   |--AT -> @ [75:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [75:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [76:17]
|       |       |       |                   |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [76:24]
|       |       |       |                   |   |   |--GENERIC_START -> < [76:24]
|       |       |       |                   |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [76:25]
|       |       |       |                   |   |   |   `--IDENT -> T [76:25]
|       |       |       |                   |   |   `--GENERIC_END -> > [76:26]
|       |       |       |                   |   |--TYPE -> TYPE [76:28]
|       |       |       |                   |   |   |--IDENT -> T [76:28]
|       |       |       |                   |   |   `--ARRAY_DECLARATOR -> [ [76:29]
|       |       |       |                   |   |       `--RBRACK -> ] [76:30]
|       |       |       |                   |   |--IDENT -> toArray [76:32]
|       |       |       |                   |   |--LPAREN -> ( [76:39]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [76:40]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [76:40]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [76:40]
|       |       |       |                   |   |       |--TYPE -> TYPE [76:40]
|       |       |       |                   |   |       |   |--IDENT -> T [76:40]
|       |       |       |                   |   |       |   `--ARRAY_DECLARATOR -> [ [76:41]
|       |       |       |                   |   |       |       `--RBRACK -> ] [76:42]
|       |       |       |                   |   |       `--IDENT -> a [76:44]
|       |       |       |                   |   |--RPAREN -> ) [76:45]
|       |       |       |                   |   `--SLIST -> { [76:47]
|       |       |       |                   |       |--LITERAL_RETURN -> return [77:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [77:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [77:28]
|       |       |       |                   |       |   `--SEMI -> ; [77:32]
|       |       |       |                   |       `--RCURLY -> } [78:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [80:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [80:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [80:17]
|       |       |       |                   |   |   |   |--AT -> @ [80:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [80:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [81:17]
|       |       |       |                   |   |--TYPE -> TYPE [81:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [81:24]
|       |       |       |                   |   |--IDENT -> add [81:32]
|       |       |       |                   |   |--LPAREN -> ( [81:35]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [81:36]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [81:36]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [81:36]
|       |       |       |                   |   |       |--TYPE -> TYPE [81:36]
|       |       |       |                   |   |       |   `--IDENT -> String [81:36]
|       |       |       |                   |   |       `--IDENT -> s [81:43]
|       |       |       |                   |   |--RPAREN -> ) [81:44]
|       |       |       |                   |   `--SLIST -> { [81:46]
|       |       |       |                   |       |--LITERAL_RETURN -> return [82:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [82:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [82:28]
|       |       |       |                   |       |   `--SEMI -> ; [82:33]
|       |       |       |                   |       `--RCURLY -> } [83:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [85:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [85:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [85:17]
|       |       |       |                   |   |   |   |--AT -> @ [85:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [85:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [86:17]
|       |       |       |                   |   |--TYPE -> TYPE [86:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [86:24]
|       |       |       |                   |   |--IDENT -> remove [86:32]
|       |       |       |                   |   |--LPAREN -> ( [86:38]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [86:39]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [86:39]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [86:39]
|       |       |       |                   |   |       |--TYPE -> TYPE [86:39]
|       |       |       |                   |   |       |   `--IDENT -> Object [86:39]
|       |       |       |                   |   |       `--IDENT -> o [86:46]
|       |       |       |                   |   |--RPAREN -> ) [86:47]
|       |       |       |                   |   `--SLIST -> { [86:49]
|       |       |       |                   |       |--LITERAL_RETURN -> return [87:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [87:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [87:28]
|       |       |       |                   |       |   `--SEMI -> ; [87:33]
|       |       |       |                   |       `--RCURLY -> } [88:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [90:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [90:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [90:17]
|       |       |       |                   |   |   |   |--AT -> @ [90:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [90:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [91:17]
|       |       |       |                   |   |--TYPE -> TYPE [91:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [91:24]
|       |       |       |                   |   |--IDENT -> containsAll [91:32]
|       |       |       |                   |   |--LPAREN -> ( [91:43]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [91:44]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [91:44]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [91:44]
|       |       |       |                   |   |       |--TYPE -> TYPE [91:44]
|       |       |       |                   |   |       |   |--IDENT -> Collection [91:44]
|       |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [91:54]
|       |       |       |                   |   |       |       |--GENERIC_START -> < [91:54]
|       |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [91:55]
|       |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [91:55]
|       |       |       |                   |   |       |       `--GENERIC_END -> > [91:56]
|       |       |       |                   |   |       `--IDENT -> c [91:58]
|       |       |       |                   |   |--RPAREN -> ) [91:59]
|       |       |       |                   |   `--SLIST -> { [91:61]
|       |       |       |                   |       |--LITERAL_RETURN -> return [92:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [92:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [92:28]
|       |       |       |                   |       |   `--SEMI -> ; [92:33]
|       |       |       |                   |       `--RCURLY -> } [93:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [95:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [95:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [95:17]
|       |       |       |                   |   |   |   |--AT -> @ [95:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [95:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [96:17]
|       |       |       |                   |   |--TYPE -> TYPE [96:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [96:24]
|       |       |       |                   |   |--IDENT -> addAll [96:32]
|       |       |       |                   |   |--LPAREN -> ( [96:38]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [96:39]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [96:39]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [96:39]
|       |       |       |                   |   |       |--TYPE -> TYPE [96:39]
|       |       |       |                   |   |       |   |--IDENT -> Collection [96:39]
|       |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [96:49]
|       |       |       |                   |   |       |       |--GENERIC_START -> < [96:49]
|       |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [96:50]
|       |       |       |                   |   |       |       |   |--WILDCARD_TYPE -> ? [96:50]
|       |       |       |                   |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [96:52]
|       |       |       |                   |   |       |       |       `--IDENT -> String [96:60]
|       |       |       |                   |   |       |       `--GENERIC_END -> > [96:66]
|       |       |       |                   |   |       `--IDENT -> c [96:68]
|       |       |       |                   |   |--RPAREN -> ) [96:69]
|       |       |       |                   |   `--SLIST -> { [96:71]
|       |       |       |                   |       |--LITERAL_RETURN -> return [97:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [97:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [97:28]
|       |       |       |                   |       |   `--SEMI -> ; [97:33]
|       |       |       |                   |       `--RCURLY -> } [98:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [100:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [100:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [100:17]
|       |       |       |                   |   |   |   |--AT -> @ [100:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [100:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [101:17]
|       |       |       |                   |   |--TYPE -> TYPE [101:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [101:24]
|       |       |       |                   |   |--IDENT -> addAll [101:32]
|       |       |       |                   |   |--LPAREN -> ( [101:38]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [101:39]
|       |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [101:39]
|       |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [101:39]
|       |       |       |                   |   |   |   |--TYPE -> TYPE [101:39]
|       |       |       |                   |   |   |   |   `--LITERAL_INT -> int [101:39]
|       |       |       |                   |   |   |   `--IDENT -> index [101:43]
|       |       |       |                   |   |   |--COMMA -> , [101:48]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [101:50]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [101:50]
|       |       |       |                   |   |       |--TYPE -> TYPE [101:50]
|       |       |       |                   |   |       |   |--IDENT -> Collection [101:50]
|       |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [101:60]
|       |       |       |                   |   |       |       |--GENERIC_START -> < [101:60]
|       |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [101:61]
|       |       |       |                   |   |       |       |   |--WILDCARD_TYPE -> ? [101:61]
|       |       |       |                   |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [101:63]
|       |       |       |                   |   |       |       |       `--IDENT -> String [101:71]
|       |       |       |                   |   |       |       `--GENERIC_END -> > [101:77]
|       |       |       |                   |   |       `--IDENT -> c [101:79]
|       |       |       |                   |   |--RPAREN -> ) [101:80]
|       |       |       |                   |   `--SLIST -> { [101:82]
|       |       |       |                   |       |--LITERAL_RETURN -> return [102:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [102:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [102:28]
|       |       |       |                   |       |   `--SEMI -> ; [102:33]
|       |       |       |                   |       `--RCURLY -> } [103:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [105:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [105:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [105:17]
|       |       |       |                   |   |   |   |--AT -> @ [105:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [105:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [106:17]
|       |       |       |                   |   |--TYPE -> TYPE [106:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [106:24]
|       |       |       |                   |   |--IDENT -> removeAll [106:32]
|       |       |       |                   |   |--LPAREN -> ( [106:41]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [106:42]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [106:42]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [106:42]
|       |       |       |                   |   |       |--TYPE -> TYPE [106:42]
|       |       |       |                   |   |       |   |--IDENT -> Collection [106:42]
|       |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [106:52]
|       |       |       |                   |   |       |       |--GENERIC_START -> < [106:52]
|       |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [106:53]
|       |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [106:53]
|       |       |       |                   |   |       |       `--GENERIC_END -> > [106:54]
|       |       |       |                   |   |       `--IDENT -> c [106:56]
|       |       |       |                   |   |--RPAREN -> ) [106:57]
|       |       |       |                   |   `--SLIST -> { [106:59]
|       |       |       |                   |       |--LITERAL_RETURN -> return [107:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [107:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [107:28]
|       |       |       |                   |       |   `--SEMI -> ; [107:33]
|       |       |       |                   |       `--RCURLY -> } [108:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [110:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [110:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [110:17]
|       |       |       |                   |   |   |   |--AT -> @ [110:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [110:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [111:17]
|       |       |       |                   |   |--TYPE -> TYPE [111:24]
|       |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [111:24]
|       |       |       |                   |   |--IDENT -> retainAll [111:32]
|       |       |       |                   |   |--LPAREN -> ( [111:41]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [111:42]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [111:42]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [111:42]
|       |       |       |                   |   |       |--TYPE -> TYPE [111:42]
|       |       |       |                   |   |       |   |--IDENT -> Collection [111:42]
|       |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [111:52]
|       |       |       |                   |   |       |       |--GENERIC_START -> < [111:52]
|       |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [111:53]
|       |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [111:53]
|       |       |       |                   |   |       |       `--GENERIC_END -> > [111:54]
|       |       |       |                   |   |       `--IDENT -> c [111:56]
|       |       |       |                   |   |--RPAREN -> ) [111:57]
|       |       |       |                   |   `--SLIST -> { [111:59]
|       |       |       |                   |       |--LITERAL_RETURN -> return [112:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [112:28]
|       |       |       |                   |       |   |   `--LITERAL_FALSE -> false [112:28]
|       |       |       |                   |       |   `--SEMI -> ; [112:33]
|       |       |       |                   |       `--RCURLY -> } [113:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [115:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [115:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [115:17]
|       |       |       |                   |   |   |   |--AT -> @ [115:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [115:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [116:17]
|       |       |       |                   |   |--TYPE -> TYPE [116:24]
|       |       |       |                   |   |   `--LITERAL_VOID -> void [116:24]
|       |       |       |                   |   |--IDENT -> clear [116:29]
|       |       |       |                   |   |--LPAREN -> ( [116:34]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [116:35]
|       |       |       |                   |   |--RPAREN -> ) [116:35]
|       |       |       |                   |   `--SLIST -> { [116:37]
|       |       |       |                   |       `--RCURLY -> } [118:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [120:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [120:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [120:17]
|       |       |       |                   |   |   |   |--AT -> @ [120:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [120:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [121:17]
|       |       |       |                   |   |--TYPE -> TYPE [121:24]
|       |       |       |                   |   |   `--IDENT -> String [121:24]
|       |       |       |                   |   |--IDENT -> get [121:31]
|       |       |       |                   |   |--LPAREN -> ( [121:34]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [121:35]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [121:35]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [121:35]
|       |       |       |                   |   |       |--TYPE -> TYPE [121:35]
|       |       |       |                   |   |       |   `--LITERAL_INT -> int [121:35]
|       |       |       |                   |   |       `--IDENT -> index [121:39]
|       |       |       |                   |   |--RPAREN -> ) [121:44]
|       |       |       |                   |   `--SLIST -> { [121:46]
|       |       |       |                   |       |--LITERAL_RETURN -> return [122:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [122:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [122:28]
|       |       |       |                   |       |   `--SEMI -> ; [122:32]
|       |       |       |                   |       `--RCURLY -> } [123:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [125:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [125:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [125:17]
|       |       |       |                   |   |   |   |--AT -> @ [125:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [125:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [126:17]
|       |       |       |                   |   |--TYPE -> TYPE [126:24]
|       |       |       |                   |   |   `--IDENT -> String [126:24]
|       |       |       |                   |   |--IDENT -> set [126:31]
|       |       |       |                   |   |--LPAREN -> ( [126:34]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [126:35]
|       |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [126:35]
|       |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [126:35]
|       |       |       |                   |   |   |   |--TYPE -> TYPE [126:35]
|       |       |       |                   |   |   |   |   `--LITERAL_INT -> int [126:35]
|       |       |       |                   |   |   |   `--IDENT -> index [126:39]
|       |       |       |                   |   |   |--COMMA -> , [126:44]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [126:46]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [126:46]
|       |       |       |                   |   |       |--TYPE -> TYPE [126:46]
|       |       |       |                   |   |       |   `--IDENT -> String [126:46]
|       |       |       |                   |   |       `--IDENT -> element [126:53]
|       |       |       |                   |   |--RPAREN -> ) [126:60]
|       |       |       |                   |   `--SLIST -> { [126:62]
|       |       |       |                   |       |--LITERAL_RETURN -> return [127:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [127:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [127:28]
|       |       |       |                   |       |   `--SEMI -> ; [127:32]
|       |       |       |                   |       `--RCURLY -> } [128:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [130:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [130:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [130:17]
|       |       |       |                   |   |   |   |--AT -> @ [130:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [130:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [131:17]
|       |       |       |                   |   |--TYPE -> TYPE [131:24]
|       |       |       |                   |   |   `--LITERAL_VOID -> void [131:24]
|       |       |       |                   |   |--IDENT -> add [131:29]
|       |       |       |                   |   |--LPAREN -> ( [131:32]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [131:33]
|       |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [131:33]
|       |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [131:33]
|       |       |       |                   |   |   |   |--TYPE -> TYPE [131:33]
|       |       |       |                   |   |   |   |   `--LITERAL_INT -> int [131:33]
|       |       |       |                   |   |   |   `--IDENT -> index [131:37]
|       |       |       |                   |   |   |--COMMA -> , [131:42]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [131:44]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [131:44]
|       |       |       |                   |   |       |--TYPE -> TYPE [131:44]
|       |       |       |                   |   |       |   `--IDENT -> String [131:44]
|       |       |       |                   |   |       `--IDENT -> element [131:51]
|       |       |       |                   |   |--RPAREN -> ) [131:58]
|       |       |       |                   |   `--SLIST -> { [131:60]
|       |       |       |                   |       `--RCURLY -> } [133:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [135:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [135:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [135:17]
|       |       |       |                   |   |   |   |--AT -> @ [135:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [135:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [136:17]
|       |       |       |                   |   |--TYPE -> TYPE [136:24]
|       |       |       |                   |   |   `--IDENT -> String [136:24]
|       |       |       |                   |   |--IDENT -> remove [136:31]
|       |       |       |                   |   |--LPAREN -> ( [136:37]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [136:38]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [136:38]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [136:38]
|       |       |       |                   |   |       |--TYPE -> TYPE [136:38]
|       |       |       |                   |   |       |   `--LITERAL_INT -> int [136:38]
|       |       |       |                   |   |       `--IDENT -> index [136:42]
|       |       |       |                   |   |--RPAREN -> ) [136:47]
|       |       |       |                   |   `--SLIST -> { [136:49]
|       |       |       |                   |       |--LITERAL_RETURN -> return [137:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [137:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [137:28]
|       |       |       |                   |       |   `--SEMI -> ; [137:32]
|       |       |       |                   |       `--RCURLY -> } [138:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [140:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [140:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [140:17]
|       |       |       |                   |   |   |   |--AT -> @ [140:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [140:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [141:17]
|       |       |       |                   |   |--TYPE -> TYPE [141:24]
|       |       |       |                   |   |   `--LITERAL_INT -> int [141:24]
|       |       |       |                   |   |--IDENT -> indexOf [141:28]
|       |       |       |                   |   |--LPAREN -> ( [141:35]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [141:36]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [141:36]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [141:36]
|       |       |       |                   |   |       |--TYPE -> TYPE [141:36]
|       |       |       |                   |   |       |   `--IDENT -> Object [141:36]
|       |       |       |                   |   |       `--IDENT -> o [141:43]
|       |       |       |                   |   |--RPAREN -> ) [141:44]
|       |       |       |                   |   `--SLIST -> { [141:46]
|       |       |       |                   |       |--LITERAL_RETURN -> return [142:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [142:28]
|       |       |       |                   |       |   |   `--NUM_INT -> 0 [142:28]
|       |       |       |                   |       |   `--SEMI -> ; [142:29]
|       |       |       |                   |       `--RCURLY -> } [143:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [145:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [145:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [145:17]
|       |       |       |                   |   |   |   |--AT -> @ [145:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [145:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [146:17]
|       |       |       |                   |   |--TYPE -> TYPE [146:24]
|       |       |       |                   |   |   `--LITERAL_INT -> int [146:24]
|       |       |       |                   |   |--IDENT -> lastIndexOf [146:28]
|       |       |       |                   |   |--LPAREN -> ( [146:39]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [146:40]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [146:40]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [146:40]
|       |       |       |                   |   |       |--TYPE -> TYPE [146:40]
|       |       |       |                   |   |       |   `--IDENT -> Object [146:40]
|       |       |       |                   |   |       `--IDENT -> o [146:47]
|       |       |       |                   |   |--RPAREN -> ) [146:48]
|       |       |       |                   |   `--SLIST -> { [146:50]
|       |       |       |                   |       |--LITERAL_RETURN -> return [147:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [147:28]
|       |       |       |                   |       |   |   `--NUM_INT -> 0 [147:28]
|       |       |       |                   |       |   `--SEMI -> ; [147:29]
|       |       |       |                   |       `--RCURLY -> } [148:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [150:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [150:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [150:17]
|       |       |       |                   |   |   |   |--AT -> @ [150:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [150:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [151:17]
|       |       |       |                   |   |--TYPE -> TYPE [151:24]
|       |       |       |                   |   |   |--IDENT -> ListIterator [151:24]
|       |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [151:36]
|       |       |       |                   |   |       |--GENERIC_START -> < [151:36]
|       |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [151:37]
|       |       |       |                   |   |       |   `--IDENT -> String [151:37]
|       |       |       |                   |   |       `--GENERIC_END -> > [151:43]
|       |       |       |                   |   |--IDENT -> listIterator [151:45]
|       |       |       |                   |   |--LPAREN -> ( [151:57]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [151:58]
|       |       |       |                   |   |--RPAREN -> ) [151:58]
|       |       |       |                   |   `--SLIST -> { [151:60]
|       |       |       |                   |       |--LITERAL_RETURN -> return [152:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [152:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [152:28]
|       |       |       |                   |       |   `--SEMI -> ; [152:32]
|       |       |       |                   |       `--RCURLY -> } [153:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [155:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [155:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [155:17]
|       |       |       |                   |   |   |   |--AT -> @ [155:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [155:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [156:17]
|       |       |       |                   |   |--TYPE -> TYPE [156:24]
|       |       |       |                   |   |   |--IDENT -> ListIterator [156:24]
|       |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [156:36]
|       |       |       |                   |   |       |--GENERIC_START -> < [156:36]
|       |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [156:37]
|       |       |       |                   |   |       |   `--IDENT -> String [156:37]
|       |       |       |                   |   |       `--GENERIC_END -> > [156:43]
|       |       |       |                   |   |--IDENT -> listIterator [156:45]
|       |       |       |                   |   |--LPAREN -> ( [156:57]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [156:58]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [156:58]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [156:58]
|       |       |       |                   |   |       |--TYPE -> TYPE [156:58]
|       |       |       |                   |   |       |   `--LITERAL_INT -> int [156:58]
|       |       |       |                   |   |       `--IDENT -> index [156:62]
|       |       |       |                   |   |--RPAREN -> ) [156:67]
|       |       |       |                   |   `--SLIST -> { [156:69]
|       |       |       |                   |       |--LITERAL_RETURN -> return [157:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [157:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [157:28]
|       |       |       |                   |       |   `--SEMI -> ; [157:32]
|       |       |       |                   |       `--RCURLY -> } [158:17]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [160:17]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [160:17]
|       |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [160:17]
|       |       |       |                   |   |   |   |--AT -> @ [160:17]
|       |       |       |                   |   |   |   `--IDENT -> Override [160:18]
|       |       |       |                   |   |   `--LITERAL_PUBLIC -> public [161:17]
|       |       |       |                   |   |--TYPE -> TYPE [161:24]
|       |       |       |                   |   |   |--IDENT -> List [161:24]
|       |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [161:28]
|       |       |       |                   |   |       |--GENERIC_START -> < [161:28]
|       |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [161:29]
|       |       |       |                   |   |       |   `--IDENT -> String [161:29]
|       |       |       |                   |   |       `--GENERIC_END -> > [161:35]
|       |       |       |                   |   |--IDENT -> subList [161:37]
|       |       |       |                   |   |--LPAREN -> ( [161:44]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [161:45]
|       |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [161:45]
|       |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [161:45]
|       |       |       |                   |   |   |   |--TYPE -> TYPE [161:45]
|       |       |       |                   |   |   |   |   `--LITERAL_INT -> int [161:45]
|       |       |       |                   |   |   |   `--IDENT -> fromIndex [161:49]
|       |       |       |                   |   |   |--COMMA -> , [161:58]
|       |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [161:60]
|       |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [161:60]
|       |       |       |                   |   |       |--TYPE -> TYPE [161:60]
|       |       |       |                   |   |       |   `--LITERAL_INT -> int [161:60]
|       |       |       |                   |   |       `--IDENT -> toIndex [161:64]
|       |       |       |                   |   |--RPAREN -> ) [161:71]
|       |       |       |                   |   `--SLIST -> { [161:73]
|       |       |       |                   |       |--LITERAL_RETURN -> return [162:21]
|       |       |       |                   |       |   |--EXPR -> EXPR [162:28]
|       |       |       |                   |       |   |   `--LITERAL_NULL -> null [162:28]
|       |       |       |                   |       |   `--SEMI -> ; [162:32]
|       |       |       |                   |       `--RCURLY -> } [163:17]
|       |       |       |                   `--RCURLY -> } [164:13]
|       |       |       |--SEMI -> ; [164:14]
|       |       |       `--RCURLY -> } [165:9]
|       |       `--RCURLY -> } [166:5]
|       |--CLASS_DEF -> CLASS_DEF [168:5]
|       |   |--MODIFIERS -> MODIFIERS [168:5]
|       |   |--LITERAL_CLASS -> class [168:5]
|       |   |--IDENT -> OtherInner [168:11]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [168:21]
|       |   |   |--GENERIC_START -> < [168:21]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [168:22]
|       |   |   |   `--IDENT -> E [168:22]
|       |   |   `--GENERIC_END -> > [168:23]
|       |   `--OBJBLOCK -> OBJBLOCK [168:25]
|       |       |--LCURLY -> { [168:25]
|       |       |--CTOR_DEF -> CTOR_DEF [169:9]
|       |       |   |--MODIFIERS -> MODIFIERS [169:9]
|       |       |   |--IDENT -> OtherInner [169:9]
|       |       |   |--LPAREN -> ( [169:19]
|       |       |   |--PARAMETERS -> PARAMETERS [169:20]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [169:20]
|       |       |   |       |--MODIFIERS -> MODIFIERS [169:20]
|       |       |   |       |--TYPE -> TYPE [169:20]
|       |       |   |       |   `--LITERAL_INT -> int [169:20]
|       |       |   |       `--IDENT -> w [169:24]
|       |       |   |--RPAREN -> ) [169:25]
|       |       |   `--SLIST -> { [169:26]
|       |       |       `--RCURLY -> } [169:27]
|       |       |--CTOR_DEF -> CTOR_DEF [170:9]
|       |       |   |--MODIFIERS -> MODIFIERS [170:9]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [170:9]
|       |       |   |   |--GENERIC_START -> < [170:9]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [170:10]
|       |       |   |   |   |--IDENT -> T [170:10]
|       |       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [170:12]
|       |       |   |   |       `--IDENT -> Serializable [170:20]
|       |       |   |   `--GENERIC_END -> > [170:32]
|       |       |   |--IDENT -> OtherInner [170:34]
|       |       |   |--LPAREN -> ( [170:44]
|       |       |   |--PARAMETERS -> PARAMETERS [170:45]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [170:45]
|       |       |   |       |--MODIFIERS -> MODIFIERS [170:45]
|       |       |   |       |--TYPE -> TYPE [170:45]
|       |       |   |       |   `--IDENT -> T [170:45]
|       |       |   |       `--IDENT -> element [170:47]
|       |       |   |--RPAREN -> ) [170:54]
|       |       |   `--SLIST -> { [170:56]
|       |       |       `--RCURLY -> } [172:9]
|       |       |--CTOR_DEF -> CTOR_DEF [173:9]
|       |       |   |--MODIFIERS -> MODIFIERS [173:9]
|       |       |   |--IDENT -> OtherInner [173:9]
|       |       |   |--LPAREN -> ( [173:19]
|       |       |   |--PARAMETERS -> PARAMETERS [173:20]
|       |       |   |--RPAREN -> ) [173:20]
|       |       |   `--SLIST -> { [173:22]
|       |       |       |--CTOR_CALL -> this [174:16]
|       |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [174:13]
|       |       |       |   |   |--GENERIC_START -> < [174:13]
|       |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [174:14]
|       |       |       |   |   |   `--IDENT -> E [174:14]
|       |       |       |   |   `--GENERIC_END -> > [174:15]
|       |       |       |   |--LPAREN -> ( [174:20]
|       |       |       |   |--ELIST -> ELIST [174:21]
|       |       |       |   |   `--EXPR -> EXPR [174:21]
|       |       |       |   |       `--NUM_INT -> 2 [174:21]
|       |       |       |   |--RPAREN -> ) [174:22]
|       |       |       |   `--SEMI -> ; [174:23]
|       |       |       `--RCURLY -> } [175:9]
|       |       `--RCURLY -> } [176:5]
|       |--METHOD_DEF -> METHOD_DEF [178:5]
|       |   |--MODIFIERS -> MODIFIERS [178:5]
|       |   |   `--LITERAL_PRIVATE -> private [178:5]
|       |   |--TYPE -> TYPE [178:13]
|       |   |   `--LITERAL_VOID -> void [178:13]
|       |   |--IDENT -> killAll [178:18]
|       |   |--LPAREN -> ( [178:25]
|       |   |--PARAMETERS -> PARAMETERS [178:26]
|       |   |--RPAREN -> ) [178:26]
|       |   `--SLIST -> { [178:28]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [179:11]
|       |       |   |--MODIFIERS -> MODIFIERS [179:11]
|       |       |   |--TYPE -> TYPE [179:11]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [179:11]
|       |       |   |--IDENT -> oneAlive [179:19]
|       |       |   `--ASSIGN -> = [179:28]
|       |       |       `--EXPR -> EXPR [179:30]
|       |       |           `--LITERAL_FALSE -> false [179:30]
|       |       |--SEMI -> ; [179:35]
|       |       |--LITERAL_IF -> if [180:15]
|       |       |   |--LPAREN -> ( [180:18]
|       |       |   |--EXPR -> EXPR [180:19]
|       |       |   |   `--IDENT -> oneAlive [180:19]
|       |       |   |--RPAREN -> ) [180:27]
|       |       |   `--SLIST -> { [180:29]
|       |       |       |--EXPR -> EXPR [181:31]
|       |       |       |   `--METHOD_CALL -> ( [181:31]
|       |       |       |       |--DOT -> . [181:25]
|       |       |       |       |   |--IDENT -> Thread [181:19]
|       |       |       |       |   `--IDENT -> yield [181:26]
|       |       |       |       |--ELIST -> ELIST [181:32]
|       |       |       |       `--RPAREN -> ) [181:32]
|       |       |       |--SEMI -> ; [181:33]
|       |       |       `--RCURLY -> } [182:15]
|       |       `--RCURLY -> } [184:7]
|       |--CLASS_DEF -> CLASS_DEF [185:5]
|       |   |--MODIFIERS -> MODIFIERS [185:5]
|       |   |--LITERAL_CLASS -> class [185:5]
|       |   |--IDENT -> SuperClassA [185:11]
|       |   `--OBJBLOCK -> OBJBLOCK [185:22]
|       |       |--LCURLY -> { [185:22]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [186:9]
|       |       |   |--MODIFIERS -> MODIFIERS [186:9]
|       |       |   |   `--LITERAL_PROTECTED -> protected [186:9]
|       |       |   |--TYPE -> TYPE [186:19]
|       |       |   |   `--IDENT -> SuperClassA [186:19]
|       |       |   |--IDENT -> bs [186:31]
|       |       |   `--SEMI -> ; [186:33]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [187:9]
|       |       |   |--MODIFIERS -> MODIFIERS [187:9]
|       |       |   |   `--LITERAL_PROTECTED -> protected [187:9]
|       |       |   |--TYPE -> TYPE [187:19]
|       |       |   |   `--IDENT -> SuperClassA [187:19]
|       |       |   |--IDENT -> s [187:31]
|       |       |   `--SEMI -> ; [187:32]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [188:9]
|       |       |   |--MODIFIERS -> MODIFIERS [188:9]
|       |       |   |--TYPE -> TYPE [188:9]
|       |       |   |   `--IDENT -> Object [188:9]
|       |       |   |--IDENT -> s2 [188:16]
|       |       |   `--SEMI -> ; [188:18]
|       |       `--RCURLY -> } [189:5]
|       |--CLASS_DEF -> CLASS_DEF [190:5]
|       |   |--MODIFIERS -> MODIFIERS [190:5]
|       |   |--LITERAL_CLASS -> class [190:5]
|       |   |--IDENT -> SuperClassA2 [190:11]
|       |   `--OBJBLOCK -> OBJBLOCK [190:23]
|       |       |--LCURLY -> { [190:23]
|       |       `--RCURLY -> } [190:24]
|       |--CLASS_DEF -> CLASS_DEF [197:5]
|       |   |--MODIFIERS -> MODIFIERS [197:5]
|       |   |   |--BLOCK_COMMENT_BEGIN -> /* [193:5]
|       |   |   |   |--COMMENT_CONTENT -> \n     * Note: inherited fields of a nested class shadow outer scope variables\n     *      Note: only if they are accessible!\n      [193:7]
|       |   |   |   `--BLOCK_COMMENT_END -> */ [196:6]
|       |   |   `--LITERAL_PUBLIC -> public [197:5]
|       |   |--LITERAL_CLASS -> class [197:12]
|       |   |--IDENT -> FieldAccessSuper [197:18]
|       |   |--EXTENDS_CLAUSE -> extends [197:35]
|       |   |   `--IDENT -> SuperClassA [197:43]
|       |   `--OBJBLOCK -> OBJBLOCK [197:55]
|       |       |--LCURLY -> { [197:55]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [198:9]
|       |       |   |--MODIFIERS -> MODIFIERS [198:9]
|       |       |   |   `--LITERAL_PRIVATE -> private [198:9]
|       |       |   |--TYPE -> TYPE [198:17]
|       |       |   |   `--IDENT -> SuperClassA [198:17]
|       |       |   |--IDENT -> s [198:29]
|       |       |   `--SEMI -> ; [198:30]
|       |       |--METHOD_DEF -> METHOD_DEF [200:9]
|       |       |   |--MODIFIERS -> MODIFIERS [200:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [200:9]
|       |       |   |--TYPE -> TYPE [200:16]
|       |       |   |   `--LITERAL_VOID -> void [200:16]
|       |       |   |--IDENT -> foo [200:21]
|       |       |   |--LPAREN -> ( [200:24]
|       |       |   |--PARAMETERS -> PARAMETERS [200:25]
|       |       |   |--RPAREN -> ) [200:25]
|       |       |   `--SLIST -> { [200:27]
|       |       |       |--EXPR -> EXPR [203:15]
|       |       |       |   `--ASSIGN -> = [203:15]
|       |       |       |       |--SINGLE_LINE_COMMENT -> // [201:13]
|       |       |       |       |   `--COMMENT_CONTENT ->  simple super field access\n [201:15]
|       |       |       |       |--SINGLE_LINE_COMMENT -> // [202:13]
|       |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s]]]\n [202:15]
|       |       |       |       |--IDENT -> s [203:13]
|       |       |       |       `--LITERAL_NEW -> new [203:17]
|       |       |       |           |--IDENT -> SuperClassA [203:21]
|       |       |       |           |--LPAREN -> ( [203:32]
|       |       |       |           |--ELIST -> ELIST [203:33]
|       |       |       |           `--RPAREN -> ) [203:33]
|       |       |       |--SEMI -> ; [203:34]
|       |       |       |--EXPR -> EXPR [207:25]
|       |       |       |   `--ASSIGN -> = [207:25]
|       |       |       |       |--DOT -> . [207:21]
|       |       |       |       |   |--DOT -> . [207:19]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [205:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  access inherited field through primary\n [205:15]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [206:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[ Prefix[Primary[(this)]], Suffix[s], Suffix[s2] ]\n [206:15]
|       |       |       |       |   |   |--LPAREN -> ( [207:13]
|       |       |       |       |   |   |--LITERAL_THIS -> this [207:14]
|       |       |       |       |   |   |--RPAREN -> ) [207:18]
|       |       |       |       |   |   `--IDENT -> s [207:20]
|       |       |       |       |   `--IDENT -> s2 [207:22]
|       |       |       |       `--LITERAL_NEW -> new [207:27]
|       |       |       |           |--IDENT -> SuperClassA2 [207:31]
|       |       |       |           |--LPAREN -> ( [207:43]
|       |       |       |           |--ELIST -> ELIST [207:44]
|       |       |       |           `--RPAREN -> ) [207:44]
|       |       |       |--SEMI -> ; [207:45]
|       |       |       |--EXPR -> EXPR [211:20]
|       |       |       |   `--ASSIGN -> = [211:20]
|       |       |       |       |--DOT -> . [211:16]
|       |       |       |       |   |--DOT -> . [211:14]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [209:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  access inherited field, second 's' has inherited field 's2'\n [209:15]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [210:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s.s.s2]]]\n [210:15]
|       |       |       |       |   |   |--IDENT -> s [211:13]
|       |       |       |       |   |   `--IDENT -> s [211:15]
|       |       |       |       |   `--IDENT -> s2 [211:17]
|       |       |       |       `--LITERAL_NEW -> new [211:22]
|       |       |       |           |--IDENT -> SuperClassA2 [211:26]
|       |       |       |           |--LPAREN -> ( [211:38]
|       |       |       |           |--ELIST -> ELIST [211:39]
|       |       |       |           `--RPAREN -> ) [211:39]
|       |       |       |--SEMI -> ; [211:40]
|       |       |       |--EXPR -> EXPR [215:21]
|       |       |       |   `--ASSIGN -> = [215:21]
|       |       |       |       |--DOT -> . [215:18]
|       |       |       |       |   |--SINGLE_LINE_COMMENT -> // [213:13]
|       |       |       |       |   |   `--COMMENT_CONTENT ->  field access through super\n [213:15]
|       |       |       |       |   |--SINGLE_LINE_COMMENT -> // [214:13]
|       |       |       |       |   |   `--COMMENT_CONTENT ->  Primary[Prefix["super"], Suffix["field"]]\n [214:15]
|       |       |       |       |   |--LITERAL_SUPER -> super [215:13]
|       |       |       |       |   `--IDENT -> s [215:19]
|       |       |       |       `--LITERAL_NEW -> new [215:23]
|       |       |       |           |--IDENT -> SuperClassA [215:27]
|       |       |       |           |--LPAREN -> ( [215:38]
|       |       |       |           |--ELIST -> ELIST [215:39]
|       |       |       |           `--RPAREN -> ) [215:39]
|       |       |       |--SEMI -> ; [215:40]
|       |       |       |--EXPR -> EXPR [220:21]
|       |       |       |   `--ASSIGN -> = [220:21]
|       |       |       |       |--DOT -> . [219:34]
|       |       |       |       |   |--DOT -> . [219:29]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [217:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  fully qualified case\n [217:15]
|       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [218:13]
|       |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[net...FieldAccessSuper]], Suffix[this], Suffix[s]]\n [218:15]
|       |       |       |       |   |   |--IDENT -> FieldAccessSuper [219:13]
|       |       |       |       |   |   `--LITERAL_THIS -> this [219:30]
|       |       |       |       |   `--IDENT -> s [219:35]
|       |       |       |       `--LITERAL_NEW -> new [220:23]
|       |       |       |           |--IDENT -> SuperClassA [220:27]
|       |       |       |           |--LPAREN -> ( [220:38]
|       |       |       |           |--ELIST -> ELIST [220:39]
|       |       |       |           `--RPAREN -> ) [220:39]
|       |       |       |--SEMI -> ; [220:40]
|       |       |       `--RCURLY -> } [221:9]
|       |       |--CLASS_DEF -> CLASS_DEF [223:9]
|       |       |   |--MODIFIERS -> MODIFIERS [223:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [223:9]
|       |       |   |--LITERAL_CLASS -> class [223:16]
|       |       |   |--IDENT -> Nested [223:22]
|       |       |   |--EXTENDS_CLAUSE -> extends [223:29]
|       |       |   |   `--IDENT -> SuperClassA [223:37]
|       |       |   `--OBJBLOCK -> OBJBLOCK [223:49]
|       |       |       |--LCURLY -> { [223:49]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [224:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [224:13]
|       |       |       |   |--TYPE -> TYPE [224:13]
|       |       |       |   |   `--IDENT -> SuperClassA [224:13]
|       |       |       |   |--IDENT -> a [224:25]
|       |       |       |   `--SEMI -> ; [224:26]
|       |       |       |--CLASS_DEF -> CLASS_DEF [225:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [225:13]
|       |       |       |   |--LITERAL_CLASS -> class [225:13]
|       |       |       |   |--IDENT -> SubscriptionAdapter [225:19]
|       |       |       |   `--OBJBLOCK -> OBJBLOCK [225:38]
|       |       |       |       |--LCURLY -> { [225:38]
|       |       |       |       `--RCURLY -> } [225:39]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [226:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [226:13]
|       |       |       |   |   `--FINAL -> final [226:13]
|       |       |       |   |--TYPE -> TYPE [226:35]
|       |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [226:19]
|       |       |       |   |   |   |--COMMENT_CONTENT ->  synthetic  [226:21]
|       |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [226:31]
|       |       |       |   |   `--IDENT -> SubscriptionAdapter [226:35]
|       |       |       |   |--IDENT -> this$0 [226:55]
|       |       |       |   |--ASSIGN -> = [226:62]
|       |       |       |   |   `--EXPR -> EXPR [226:64]
|       |       |       |   |       `--LITERAL_NULL -> null [226:64]
|       |       |       |   `--SEMI -> ; [226:68]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [227:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [227:13]
|       |       |       |   |   `--FINAL -> final [227:13]
|       |       |       |   |--TYPE -> TYPE [227:35]
|       |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [227:19]
|       |       |       |   |   |   |--COMMENT_CONTENT ->  synthetic  [227:21]
|       |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [227:31]
|       |       |       |   |   `--IDENT -> Object [227:35]
|       |       |       |   |--IDENT -> val$argHolder [227:42]
|       |       |       |   |--ASSIGN -> = [227:56]
|       |       |       |   |   `--EXPR -> EXPR [227:58]
|       |       |       |   |       `--LITERAL_NULL -> null [227:58]
|       |       |       |   `--SEMI -> ; [227:62]
|       |       |       |--METHOD_DEF -> METHOD_DEF [229:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [229:13]
|       |       |       |   |   `--LITERAL_PUBLIC -> public [229:13]
|       |       |       |   |--TYPE -> TYPE [229:20]
|       |       |       |   |   `--LITERAL_VOID -> void [229:20]
|       |       |       |   |--IDENT -> foo [229:25]
|       |       |       |   |--LPAREN -> ( [229:28]
|       |       |       |   |--PARAMETERS -> PARAMETERS [229:29]
|       |       |       |   |--RPAREN -> ) [229:29]
|       |       |       |   `--SLIST -> { [229:31]
|       |       |       |       |--EXPR -> EXPR [232:19]
|       |       |       |       |   `--ASSIGN -> = [232:19]
|       |       |       |       |       |--SINGLE_LINE_COMMENT -> // [230:17]
|       |       |       |       |       |   `--COMMENT_CONTENT ->  access enclosing super field\n [230:19]
|       |       |       |       |       |--SINGLE_LINE_COMMENT -> // [231:17]
|       |       |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s]]]\n [231:19]
|       |       |       |       |       |--IDENT -> s [232:17]
|       |       |       |       |       `--LITERAL_NEW -> new [232:21]
|       |       |       |       |           |--IDENT -> SuperClassA [232:25]
|       |       |       |       |           |--LPAREN -> ( [232:36]
|       |       |       |       |           |--ELIST -> ELIST [232:37]
|       |       |       |       |           `--RPAREN -> ) [232:37]
|       |       |       |       |--SEMI -> ; [232:38]
|       |       |       |       |--EXPR -> EXPR [236:20]
|       |       |       |       |   `--ASSIGN -> = [236:20]
|       |       |       |       |       |--SINGLE_LINE_COMMENT -> // [234:17]
|       |       |       |       |       |   `--COMMENT_CONTENT ->  access Nested inherited field\n [234:19]
|       |       |       |       |       |--SINGLE_LINE_COMMENT -> // [235:17]
|       |       |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[bs]]]\n [235:19]
|       |       |       |       |       |--IDENT -> bs [236:17]
|       |       |       |       |       `--LITERAL_NEW -> new [236:22]
|       |       |       |       |           |--IDENT -> SuperClassA [236:26]
|       |       |       |       |           |--LPAREN -> ( [236:37]
|       |       |       |       |           |--ELIST -> ELIST [236:38]
|       |       |       |       |           `--RPAREN -> ) [236:38]
|       |       |       |       |--SEMI -> ; [236:39]
|       |       |       |       |--EXPR -> EXPR [241:50]
|       |       |       |       |   `--ASSIGN -> = [241:50]
|       |       |       |       |       |--DOT -> . [241:46]
|       |       |       |       |       |   |--DOT -> . [241:40]
|       |       |       |       |       |   |   |--DOT -> . [241:33]
|       |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [238:17]
|       |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->  access super field with fully qualified stuff\n [238:19]
|       |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [239:17]
|       |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix["FieldAccessSuper"], Suffix[Nested],\n [239:19]
|       |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [240:17]
|       |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->                   Suffix["super"], Suffix["bs"]]\n [240:19]
|       |       |       |       |       |   |   |   |--IDENT -> FieldAccessSuper [241:17]
|       |       |       |       |       |   |   |   `--IDENT -> Nested [241:34]
|       |       |       |       |       |   |   `--LITERAL_SUPER -> super [241:41]
|       |       |       |       |       |   `--IDENT -> bs [241:47]
|       |       |       |       |       `--LITERAL_NEW -> new [241:52]
|       |       |       |       |           |--IDENT -> SuperClassA [241:56]
|       |       |       |       |           |--LPAREN -> ( [241:67]
|       |       |       |       |           |--ELIST -> ELIST [241:68]
|       |       |       |       |           `--RPAREN -> ) [241:68]
|       |       |       |       |--SEMI -> ; [241:69]
|       |       |       |       |--EXPR -> EXPR [245:42]
|       |       |       |       |   `--ASSIGN -> = [245:42]
|       |       |       |       |       |--DOT -> . [245:39]
|       |       |       |       |       |   |--DOT -> . [245:33]
|       |       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [243:17]
|       |       |       |       |       |   |   |   `--COMMENT_CONTENT ->  refers to the enclosing class's immediate super class's field\n [243:19]
|       |       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [244:17]
|       |       |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix["FieldAccessSuper"], Suffix["super"], Suffix["s"]]\n [244:19]
|       |       |       |       |       |   |   |--IDENT -> FieldAccessSuper [245:17]
|       |       |       |       |       |   |   `--LITERAL_SUPER -> super [245:34]
|       |       |       |       |       |   `--IDENT -> s [245:40]
|       |       |       |       |       `--LITERAL_NEW -> new [245:44]
|       |       |       |       |           |--IDENT -> SuperClassA [245:48]
|       |       |       |       |           |--LPAREN -> ( [245:59]
|       |       |       |       |           |--ELIST -> ELIST [245:60]
|       |       |       |       |           `--RPAREN -> ) [245:60]
|       |       |       |       |--SEMI -> ; [245:61]
|       |       |       |       `--RCURLY -> } [246:13]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [247:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [247:13]
|       |       |       |   |--TYPE -> TYPE [247:13]
|       |       |       |   |   `--IDENT -> Object [247:13]
|       |       |       |   |--IDENT -> x [247:20]
|       |       |       |   |--ASSIGN -> = [247:22]
|       |       |       |   |   `--EXPR -> EXPR [247:62]
|       |       |       |   |       `--METHOD_CALL -> ( [247:62]
|       |       |       |   |           |--DOT -> . [247:36]
|       |       |       |   |           |   |--IDENT -> Collections [247:24]
|       |       |       |   |           |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [247:37]
|       |       |       |   |           |   |   |--GENERIC_START -> < [247:37]
|       |       |       |   |           |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [247:38]
|       |       |       |   |           |   |   |   `--IDENT -> String [247:38]
|       |       |       |   |           |   |   |--COMMA -> , [247:44]
|       |       |       |   |           |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [247:46]
|       |       |       |   |           |   |   |   `--IDENT -> Integer [247:46]
|       |       |       |   |           |   |   `--GENERIC_END -> > [247:53]
|       |       |       |   |           |   `--IDENT -> emptyMap [247:54]
|       |       |       |   |           |--ELIST -> ELIST [247:63]
|       |       |       |   |           `--RPAREN -> ) [247:63]
|       |       |       |   `--SEMI -> ; [247:64]
|       |       |       |--CTOR_DEF -> CTOR_DEF [249:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [249:13]
|       |       |       |   |--IDENT -> Nested [249:13]
|       |       |       |   |--LPAREN -> ( [249:19]
|       |       |       |   |--PARAMETERS -> PARAMETERS [249:20]
|       |       |       |   |--RPAREN -> ) [249:20]
|       |       |       |   `--SLIST -> { [249:22]
|       |       |       |       |--SUPER_CTOR_CALL -> super [250:17]
|       |       |       |       |   |--LPAREN -> ( [250:22]
|       |       |       |       |   |--ELIST -> ELIST [250:23]
|       |       |       |       |   |--RPAREN -> ) [250:23]
|       |       |       |       |   `--SEMI -> ; [250:24]
|       |       |       |       `--RCURLY -> } [251:13]
|       |       |       |--METHOD_DEF -> METHOD_DEF [253:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [253:13]
|       |       |       |   |--TYPE -> TYPE [253:13]
|       |       |       |   |   `--LITERAL_INT -> int [253:13]
|       |       |       |   |--IDENT -> bar [253:17]
|       |       |       |   |--LPAREN -> ( [253:20]
|       |       |       |   |--PARAMETERS -> PARAMETERS [253:21]
|       |       |       |   |--RPAREN -> ) [253:21]
|       |       |       |   `--SLIST -> { [253:23]
|       |       |       |       |--LITERAL_RETURN -> return [254:17]
|       |       |       |       |   |--EXPR -> EXPR [254:38]
|       |       |       |       |   |   `--METHOD_CALL -> ( [254:38]
|       |       |       |       |   |       |--DOT -> . [254:29]
|       |       |       |       |   |       |   |--LITERAL_SUPER -> super [254:24]
|       |       |       |       |   |       |   `--IDENT -> hashCode [254:30]
|       |       |       |       |   |       |--ELIST -> ELIST [254:39]
|       |       |       |       |   |       `--RPAREN -> ) [254:39]
|       |       |       |       |   `--SEMI -> ; [254:40]
|       |       |       |       `--RCURLY -> } [255:13]
|       |       |       |--METHOD_DEF -> METHOD_DEF [257:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [257:13]
|       |       |       |   |--TYPE -> TYPE [257:13]
|       |       |       |   |   `--LITERAL_BOOLEAN -> boolean [257:13]
|       |       |       |   |--IDENT -> method [257:21]
|       |       |       |   |--LPAREN -> ( [257:27]
|       |       |       |   |--PARAMETERS -> PARAMETERS [257:28]
|       |       |       |   |--RPAREN -> ) [257:28]
|       |       |       |   `--SLIST -> { [257:30]
|       |       |       |       |--LITERAL_RETURN -> return [258:17]
|       |       |       |       |   |--EXPR -> EXPR [258:36]
|       |       |       |       |   |   `--METHOD_CALL -> ( [258:36]
|       |       |       |       |   |       |--DOT -> . [258:29]
|       |       |       |       |   |       |   |--LITERAL_SUPER -> super [258:24]
|       |       |       |       |   |       |   `--IDENT -> equals [258:30]
|       |       |       |       |   |       |--ELIST -> ELIST [258:37]
|       |       |       |       |   |       |   `--EXPR -> EXPR [258:37]
|       |       |       |       |   |       |       `--LITERAL_NEW -> new [258:37]
|       |       |       |       |   |       |           |--IDENT -> Object [258:41]
|       |       |       |       |   |       |           |--LPAREN -> ( [258:47]
|       |       |       |       |   |       |           |--ELIST -> ELIST [258:48]
|       |       |       |       |   |       |           `--RPAREN -> ) [258:48]
|       |       |       |       |   |       `--RPAREN -> ) [258:49]
|       |       |       |       |   `--SEMI -> ; [258:50]
|       |       |       |       `--RCURLY -> } [259:13]
|       |       |       `--RCURLY -> } [260:9]
|       |       `--RCURLY -> } [261:5]
|       `--RCURLY -> } [264:1]
|--RECORD_DEF -> RECORD_DEF [266:1]
|   |--MODIFIERS -> MODIFIERS [266:1]
|   |--LITERAL_RECORD -> record [266:1]
|   |--IDENT -> TestRecord [266:8]
|   |--LPAREN -> ( [266:18]
|   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [266:19]
|   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [266:19]
|   |   |   |--ANNOTATIONS -> ANNOTATIONS [266:19]
|   |   |   |--TYPE -> TYPE [266:19]
|   |   |   |   |--LITERAL_INT -> int [266:19]
|   |   |   |   `--ARRAY_DECLARATOR -> [ [266:22]
|   |   |   |       `--RBRACK -> ] [266:23]
|   |   |   `--IDENT -> x [266:25]
|   |   |--COMMA -> , [266:26]
|   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [266:28]
|   |       |--ANNOTATIONS -> ANNOTATIONS [266:28]
|   |       |--TYPE -> TYPE [266:28]
|   |       |   |--LITERAL_INT -> int [266:28]
|   |       |   `--ARRAY_DECLARATOR -> [ [266:31]
|   |       |       `--RBRACK -> ] [266:32]
|   |       |--ELLIPSIS -> ... [266:33]
|   |       `--IDENT -> y [266:37]
|   |--RPAREN -> ) [266:38]
|   `--OBJBLOCK -> OBJBLOCK [266:40]
|       |--LCURLY -> { [266:40]
|       |--METHOD_DEF -> METHOD_DEF [267:5]
|       |   |--MODIFIERS -> MODIFIERS [267:5]
|       |   |--TYPE -> TYPE [267:5]
|       |   |   `--LITERAL_VOID -> void [267:5]
|       |   |--IDENT -> foo [267:10]
|       |   |--LPAREN -> ( [267:13]
|       |   |--PARAMETERS -> PARAMETERS [267:14]
|       |   |--RPAREN -> ) [267:14]
|       |   `--SLIST -> { [267:16]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [268:9]
|       |       |   |--MODIFIERS -> MODIFIERS [268:9]
|       |       |   |--TYPE -> TYPE [268:9]
|       |       |   |   `--IDENT -> Runnable [268:9]
|       |       |   |--IDENT -> r11 [268:18]
|       |       |   `--ASSIGN -> = [268:22]
|       |       |       `--EXPR -> EXPR [268:28]
|       |       |           `--METHOD_REF -> :: [268:28]
|       |       |               |--IDENT -> Main [268:24]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [268:30]
|       |       |               |   |--GENERIC_START -> < [268:30]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [268:31]
|       |       |               |   |   `--IDENT -> String [268:31]
|       |       |               |   `--GENERIC_END -> > [268:37]
|       |       |               `--LITERAL_NEW -> new [268:38]
|       |       |--SEMI -> ; [268:41]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [269:9]
|       |       |   |--MODIFIERS -> MODIFIERS [269:9]
|       |       |   |--TYPE -> TYPE [269:9]
|       |       |   |   |--IDENT -> IntFunction [269:9]
|       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [269:20]
|       |       |   |       |--GENERIC_START -> < [269:20]
|       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:21]
|       |       |   |       |   |--LITERAL_INT -> int [269:21]
|       |       |   |       |   `--ARRAY_DECLARATOR -> [ [269:24]
|       |       |   |       |       `--RBRACK -> ] [269:25]
|       |       |   |       `--GENERIC_END -> > [269:26]
|       |       |   |--IDENT -> r13 [269:28]
|       |       |   `--ASSIGN -> = [269:32]
|       |       |       `--EXPR -> EXPR [269:39]
|       |       |           `--METHOD_REF -> :: [269:39]
|       |       |               |--LITERAL_INT -> int [269:34]
|       |       |               |--ARRAY_DECLARATOR -> [ [269:37]
|       |       |               |   `--RBRACK -> ] [269:38]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [269:41]
|       |       |               |   |--GENERIC_START -> < [269:41]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:42]
|       |       |               |   |   `--IDENT -> String [269:42]
|       |       |               |   `--GENERIC_END -> > [269:48]
|       |       |               `--LITERAL_NEW -> new [269:49]
|       |       |--SEMI -> ; [269:52]
|       |       |--SINGLE_LINE_COMMENT -> // [269:54]
|       |       |   `--COMMENT_CONTENT ->  produces the same results\n [269:56]
|       |       `--RCURLY -> } [270:5]
|       `--RCURLY -> } [271:1]
|--SEMI -> ; [273:1]
|--SEMI -> ; [273:2]
`--SEMI -> ; [273:3]
