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