COMPILATION_UNIT -> COMPILATION_UNIT [1:0]
|--PACKAGE_DEF -> package [1:0]
|   |--ANNOTATIONS -> ANNOTATIONS [1:47]
|   |--DOT -> . [1:47]
|   |   |--DOT -> . [1:39]
|   |   |   |--DOT -> . [1:28]
|   |   |   |   |--DOT -> . [1:22]
|   |   |   |   |   |--DOT -> . [1:11]
|   |   |   |   |   |   |--IDENT -> com [1:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [1:12]
|   |   |   |   |   `--IDENT -> tools [1:23]
|   |   |   |   `--IDENT -> checkstyle [1:29]
|   |   |   `--IDENT -> grammar [1:40]
|   |   `--IDENT -> antlr4 [1:48]
|   `--SEMI -> ; [1:54]
|--IMPORT -> import [3:0]
|   |--DOT -> . [3:15]
|   |   |--DOT -> . [3:11]
|   |   |   |--IDENT -> java [3:7]
|   |   |   `--IDENT -> awt [3:12]
|   |   `--STAR -> * [3:16]
|   `--SEMI -> ; [3:17]
|--IMPORT -> import [4:0]
|   |--DOT -> . [4:27]
|   |   |--DOT -> . [4:16]
|   |   |   |--DOT -> . [4:11]
|   |   |   |   |--IDENT -> java [4:7]
|   |   |   |   `--IDENT -> lang [4:12]
|   |   |   `--IDENT -> annotation [4:17]
|   |   `--IDENT -> ElementType [4:28]
|   `--SEMI -> ; [4:39]
|--IMPORT -> import [5:0]
|   |--DOT -> . [5:27]
|   |   |--DOT -> . [5:16]
|   |   |   |--DOT -> . [5:11]
|   |   |   |   |--IDENT -> java [5:7]
|   |   |   |   `--IDENT -> lang [5:12]
|   |   |   `--IDENT -> annotation [5:17]
|   |   `--IDENT -> Target [5:28]
|   `--SEMI -> ; [5:34]
|--IMPORT -> import [6:0]
|   |--DOT -> . [6:24]
|   |   |--DOT -> . [6:16]
|   |   |   |--DOT -> . [6:11]
|   |   |   |   |--IDENT -> java [6:7]
|   |   |   |   `--IDENT -> lang [6:12]
|   |   |   `--IDENT -> reflect [6:17]
|   |   `--IDENT -> AnnotatedElement [6:25]
|   `--SEMI -> ; [6:41]
|--IMPORT -> import [7:0]
|   |--DOT -> . [7:16]
|   |   |--DOT -> . [7:11]
|   |   |   |--IDENT -> java [7:7]
|   |   |   `--IDENT -> util [7:12]
|   |   `--IDENT -> List [7:17]
|   `--SEMI -> ; [7:21]
|--IMPORT -> import [8:0]
|   |--DOT -> . [8:16]
|   |   |--DOT -> . [8:11]
|   |   |   |--IDENT -> java [8:7]
|   |   |   `--IDENT -> util [8:12]
|   |   `--IDENT -> Map [8:17]
|   `--SEMI -> ; [8:20]
|--IMPORT -> import [9:0]
|   |--DOT -> . [9:16]
|   |   |--DOT -> . [9:11]
|   |   |   |--IDENT -> java [9:7]
|   |   |   `--IDENT -> util [9:12]
|   |   `--IDENT -> TreeSet [9:17]
|   `--SEMI -> ; [9:24]
|--IMPORT -> import [11:0]
|   |--DOT -> . [11:20]
|   |   |--DOT -> . [11:16]
|   |   |   |--DOT -> . [11:12]
|   |   |   |   |--IDENT -> javax [11:7]
|   |   |   |   `--IDENT -> net [11:13]
|   |   |   `--IDENT -> ssl [11:17]
|   |   `--IDENT -> KeyManager [11:21]
|   `--SEMI -> ; [11:31]
|--CLASS_DEF -> CLASS_DEF [13:0]
|   |--MODIFIERS -> MODIFIERS [13:0]
|   |   `--LITERAL_PUBLIC -> public [13:0]
|   |--LITERAL_CLASS -> class [13:7]
|   |--IDENT -> InputAntlr4AstRegressionNewTypeTree [13:13]
|   `--OBJBLOCK -> OBJBLOCK [13:49]
|       |--LCURLY -> { [13:49]
|       |--CLASS_DEF -> CLASS_DEF [14:8]
|       |   |--MODIFIERS -> MODIFIERS [14:8]
|       |   |   |--LITERAL_PRIVATE -> private [14:8]
|       |   |   `--LITERAL_STATIC -> static [14:16]
|       |   |--LITERAL_CLASS -> class [14:23]
|       |   |--IDENT -> Slot [14:29]
|       |   `--OBJBLOCK -> OBJBLOCK [14:34]
|       |       |--LCURLY -> { [14:34]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
|       |       |   |--MODIFIERS -> MODIFIERS [15:8]
|       |       |   |--TYPE -> TYPE [15:8]
|       |       |   |   `--LITERAL_DOUBLE -> double [15:8]
|       |       |   |--IDENT -> sin2Phi [15:15]
|       |       |   |--ASSIGN -> = [15:23]
|       |       |   |   `--EXPR -> EXPR [15:27]
|       |       |   |       `--STAR -> * [15:27]
|       |       |   |           |--NUM_INT -> 2 [15:25]
|       |       |   |           `--METHOD_CALL -> ( [15:43]
|       |       |   |               |--DOT -> . [15:39]
|       |       |   |               |   |--IDENT -> StrictMath [15:29]
|       |       |   |               |   `--IDENT -> sin [15:40]
|       |       |   |               |--ELIST -> ELIST [15:44]
|       |       |   |               |   `--EXPR -> EXPR [15:44]
|       |       |   |               |       `--NUM_FLOAT -> 1.618033988749895 [15:44]
|       |       |   |               `--RPAREN -> ) [15:61]
|       |       |   `--SEMI -> ; [15:62]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [16:8]
|       |       |   |--MODIFIERS -> MODIFIERS [16:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [16:8]
|       |       |   |--TYPE -> TYPE [16:15]
|       |       |   |   |--LITERAL_INT -> int [16:15]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [16:18]
|       |       |   |       `--RBRACK -> ] [16:19]
|       |       |   |--IDENT -> ci [16:21]
|       |       |   `--SEMI -> ; [16:23]
|       |       `--RCURLY -> } [17:4]
|       |--CLASS_DEF -> CLASS_DEF [19:4]
|       |   |--MODIFIERS -> MODIFIERS [19:4]
|       |   |   |--LITERAL_PRIVATE -> private [19:4]
|       |   |   `--LITERAL_STATIC -> static [19:12]
|       |   |--LITERAL_CLASS -> class [19:19]
|       |   |--IDENT -> Transformer [19:25]
|       |   `--OBJBLOCK -> OBJBLOCK [19:37]
|       |       |--LCURLY -> { [19:37]
|       |       `--RCURLY -> } [21:4]
|       |--CLASS_DEF -> CLASS_DEF [23:4]
|       |   |--MODIFIERS -> MODIFIERS [23:4]
|       |   |   |--LITERAL_PRIVATE -> private [23:4]
|       |   |   `--LITERAL_STATIC -> static [23:12]
|       |   |--LITERAL_CLASS -> class [23:19]
|       |   |--IDENT -> Ef [23:25]
|       |   `--OBJBLOCK -> OBJBLOCK [23:28]
|       |       |--LCURLY -> { [23:28]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [24:8]
|       |       |   |--MODIFIERS -> MODIFIERS [24:8]
|       |       |   |--TYPE -> TYPE [24:8]
|       |       |   |   |--IDENT -> Transformer [24:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [24:19]
|       |       |   |       `--RBRACK -> ] [24:20]
|       |       |   |--IDENT -> transformers [24:22]
|       |       |   |--ASSIGN -> = [24:35]
|       |       |   |   `--EXPR -> EXPR [24:37]
|       |       |   |       `--LITERAL_NEW -> new [24:37]
|       |       |   |           |--IDENT -> Transformer [24:41]
|       |       |   |           `--ARRAY_DECLARATOR -> [ [24:52]
|       |       |   |               |--EXPR -> EXPR [24:53]
|       |       |   |               |   `--NUM_INT -> 10 [24:53]
|       |       |   |               `--RBRACK -> ] [24:55]
|       |       |   `--SEMI -> ; [24:56]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [25:8]
|       |       |   |--MODIFIERS -> MODIFIERS [25:8]
|       |       |   |   `--LITERAL_STATIC -> static [25:8]
|       |       |   |--TYPE -> TYPE [25:15]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [25:15]
|       |       |   |--IDENT -> forward [25:23]
|       |       |   |--ASSIGN -> = [25:31]
|       |       |   |   `--EXPR -> EXPR [25:33]
|       |       |   |       `--LITERAL_TRUE -> true [25:33]
|       |       |   `--SEMI -> ; [25:37]
|       |       `--RCURLY -> } [26:4]
|       |--METHOD_DEF -> METHOD_DEF [28:4]
|       |   |--MODIFIERS -> MODIFIERS [28:4]
|       |   |--TYPE -> TYPE [28:4]
|       |   |   `--LITERAL_VOID -> void [28:4]
|       |   |--IDENT -> goodMethod [28:9]
|       |   |--LPAREN -> ( [28:19]
|       |   |--PARAMETERS -> PARAMETERS [28:20]
|       |   |--RPAREN -> ) [28:20]
|       |   `--SLIST -> { [28:22]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [29:8]
|       |       |   |--MODIFIERS -> MODIFIERS [29:8]
|       |       |   |--TYPE -> TYPE [29:8]
|       |       |   |   `--IDENT -> Slot [29:8]
|       |       |   |--IDENT -> slot [29:13]
|       |       |   `--ASSIGN -> = [29:18]
|       |       |       `--EXPR -> EXPR [29:20]
|       |       |           `--LITERAL_NEW -> new [29:20]
|       |       |               |--IDENT -> Slot [29:24]
|       |       |               |--LPAREN -> ( [29:28]
|       |       |               |--ELIST -> ELIST [29:29]
|       |       |               `--RPAREN -> ) [29:29]
|       |       |--SEMI -> ; [29:30]
|       |       |--EXPR -> EXPR [30:19]
|       |       |   `--ASSIGN -> = [30:19]
|       |       |       |--INDEX_OP -> [ [30:15]
|       |       |       |   |--DOT -> . [30:12]
|       |       |       |   |   |--IDENT -> slot [30:8]
|       |       |       |   |   `--IDENT -> ci [30:13]
|       |       |       |   |--EXPR -> EXPR [30:16]
|       |       |       |   |   `--NUM_INT -> 5 [30:16]
|       |       |       |   `--RBRACK -> ] [30:17]
|       |       |       `--NUM_INT -> 10 [30:21]
|       |       |--SEMI -> ; [30:23]
|       |       |--EXPR -> EXPR [31:16]
|       |       |   `--ASSIGN -> = [31:16]
|       |       |       |--DOT -> . [31:12]
|       |       |       |   |--IDENT -> slot [31:8]
|       |       |       |   `--IDENT -> ci [31:13]
|       |       |       `--LITERAL_NEW -> new [31:18]
|       |       |           |--LITERAL_INT -> int [31:22]
|       |       |           `--ARRAY_DECLARATOR -> [ [31:25]
|       |       |               |--EXPR -> EXPR [31:26]
|       |       |               |   `--NUM_INT -> 6 [31:26]
|       |       |               `--RBRACK -> ] [31:27]
|       |       |--SEMI -> ; [31:28]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [32:8]
|       |       |   |--MODIFIERS -> MODIFIERS [32:8]
|       |       |   |--TYPE -> TYPE [32:8]
|       |       |   |   |--LITERAL_DOUBLE -> double [32:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [32:14]
|       |       |   |       `--RBRACK -> ] [32:15]
|       |       |   |--IDENT -> cZ [32:17]
|       |       |   `--ASSIGN -> = [32:20]
|       |       |       `--ARRAY_INIT -> { [32:22]
|       |       |           |--EXPR -> EXPR [32:23]
|       |       |           |   `--NUM_FLOAT -> 1.1 [32:23]
|       |       |           |--COMMA -> , [32:26]
|       |       |           |--EXPR -> EXPR [32:28]
|       |       |           |   `--NUM_FLOAT -> 1.2 [32:28]
|       |       |           `--RCURLY -> } [32:31]
|       |       |--SEMI -> ; [32:32]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [33:8]
|       |       |   |--MODIFIERS -> MODIFIERS [33:8]
|       |       |   |   `--FINAL -> final [33:8]
|       |       |   |--TYPE -> TYPE [33:14]
|       |       |   |   `--LITERAL_DOUBLE -> double [33:14]
|       |       |   |--IDENT -> dnZ [33:23]
|       |       |   `--ASSIGN -> = [33:27]
|       |       |       `--EXPR -> EXPR [33:56]
|       |       |           `--STAR -> * [33:56]
|       |       |               |--DOT -> . [33:33]
|       |       |               |   |--IDENT -> slot [33:29]
|       |       |               |   `--IDENT -> sin2Phi [33:34]
|       |       |               `--INDEX_OP -> [ [33:60]
|       |       |                   |--IDENT -> cZ [33:58]
|       |       |                   |--EXPR -> EXPR [33:61]
|       |       |                   |   `--NUM_INT -> 1 [33:61]
|       |       |                   `--RBRACK -> ] [33:62]
|       |       |--SEMI -> ; [33:63]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [35:8]
|       |       |   |--MODIFIERS -> MODIFIERS [35:8]
|       |       |   |   `--FINAL -> final [35:8]
|       |       |   |--TYPE -> TYPE [35:14]
|       |       |   |   `--IDENT -> Ef [35:14]
|       |       |   |--IDENT -> ef [35:17]
|       |       |   `--ASSIGN -> = [35:20]
|       |       |       `--EXPR -> EXPR [35:22]
|       |       |           `--LITERAL_NEW -> new [35:22]
|       |       |               |--IDENT -> Ef [35:26]
|       |       |               |--LPAREN -> ( [35:28]
|       |       |               |--ELIST -> ELIST [35:29]
|       |       |               `--RPAREN -> ) [35:29]
|       |       |--SEMI -> ; [35:30]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [36:8]
|       |       |   |--MODIFIERS -> MODIFIERS [36:8]
|       |       |   |   `--FINAL -> final [36:8]
|       |       |   |--TYPE -> TYPE [36:14]
|       |       |   |   `--IDENT -> Transformer [36:14]
|       |       |   |--IDENT -> transformer [36:26]
|       |       |   `--ASSIGN -> = [36:38]
|       |       |       `--EXPR -> EXPR [37:23]
|       |       |           `--QUESTION -> ? [37:23]
|       |       |               |--DOT -> . [37:14]
|       |       |               |   |--IDENT -> ef [37:12]
|       |       |               |   `--IDENT -> forward [37:15]
|       |       |               |--INDEX_OP -> [ [37:40]
|       |       |               |   |--DOT -> . [37:27]
|       |       |               |   |   |--IDENT -> ef [37:25]
|       |       |               |   |   `--IDENT -> transformers [37:28]
|       |       |               |   |--EXPR -> EXPR [37:64]
|       |       |               |   |   `--MINUS -> - [37:64]
|       |       |               |   |       |--DOT -> . [37:56]
|       |       |               |   |       |   |--DOT -> . [37:43]
|       |       |               |   |       |   |   |--IDENT -> ef [37:41]
|       |       |               |   |       |   |   `--IDENT -> transformers [37:44]
|       |       |               |   |       |   `--IDENT -> length [37:57]
|       |       |               |   |       `--NUM_INT -> 1 [37:66]
|       |       |               |   `--RBRACK -> ] [37:67]
|       |       |               |--COLON -> : [38:20]
|       |       |               `--INDEX_OP -> [ [38:37]
|       |       |                   |--DOT -> . [38:24]
|       |       |                   |   |--IDENT -> ef [38:22]
|       |       |                   |   `--IDENT -> transformers [38:25]
|       |       |                   |--EXPR -> EXPR [38:38]
|       |       |                   |   `--NUM_INT -> 0 [38:38]
|       |       |                   `--RBRACK -> ] [38:39]
|       |       |--SEMI -> ; [38:40]
|       |       `--RCURLY -> } [40:4]
|       |--METHOD_DEF -> METHOD_DEF [42:4]
|       |   |--MODIFIERS -> MODIFIERS [42:4]
|       |   |--TYPE -> TYPE [42:4]
|       |   |   `--LITERAL_VOID -> void [42:4]
|       |   |--IDENT -> badMethod [42:9]
|       |   |--LPAREN -> ( [42:18]
|       |   |--PARAMETERS -> PARAMETERS [42:19]
|       |   |--RPAREN -> ) [42:19]
|       |   `--SLIST -> { [42:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
|       |       |   |--MODIFIERS -> MODIFIERS [43:8]
|       |       |   |--TYPE -> TYPE [43:8]
|       |       |   |   `--IDENT -> Slot [43:8]
|       |       |   |--IDENT -> slot [43:13]
|       |       |   `--ASSIGN -> = [43:18]
|       |       |       `--EXPR -> EXPR [43:20]
|       |       |           `--LITERAL_NEW -> new [43:20]
|       |       |               |--IDENT -> Slot [43:24]
|       |       |               |--LPAREN -> ( [43:28]
|       |       |               |--ELIST -> ELIST [43:29]
|       |       |               `--RPAREN -> ) [43:29]
|       |       |--SEMI -> ; [43:30]
|       |       |--EXPR -> EXPR [44:20]
|       |       |   `--ASSIGN -> = [44:20]
|       |       |       |--INDEX_OP -> [ [44:16]
|       |       |       |   |--DOT -> . [44:12]
|       |       |       |   |   |--IDENT -> slot [44:8]
|       |       |       |   |   `--IDENT -> ci [44:13]
|       |       |       |   |--EXPR -> EXPR [44:17]
|       |       |       |   |   `--NUM_INT -> 5 [44:17]
|       |       |       |   `--RBRACK -> ] [44:18]
|       |       |       `--NUM_INT -> 10 [44:22]
|       |       |--SEMI -> ; [44:24]
|       |       |--EXPR -> EXPR [45:16]
|       |       |   `--ASSIGN -> = [45:16]
|       |       |       |--DOT -> . [45:12]
|       |       |       |   |--IDENT -> slot [45:8]
|       |       |       |   `--IDENT -> ci [45:13]
|       |       |       `--LITERAL_NEW -> new [45:18]
|       |       |           |--LITERAL_INT -> int [45:22]
|       |       |           `--ARRAY_DECLARATOR -> [ [45:26]
|       |       |               |--EXPR -> EXPR [45:27]
|       |       |               |   `--NUM_INT -> 6 [45:27]
|       |       |               `--RBRACK -> ] [45:28]
|       |       |--SEMI -> ; [45:29]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [46:8]
|       |       |   |--MODIFIERS -> MODIFIERS [46:8]
|       |       |   |--TYPE -> TYPE [46:8]
|       |       |   |   |--LITERAL_DOUBLE -> double [46:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [46:15]
|       |       |   |       `--RBRACK -> ] [46:16]
|       |       |   |--IDENT -> cZ [46:18]
|       |       |   `--ASSIGN -> = [46:21]
|       |       |       `--ARRAY_INIT -> { [46:23]
|       |       |           |--EXPR -> EXPR [46:24]
|       |       |           |   `--NUM_FLOAT -> 1.1 [46:24]
|       |       |           |--COMMA -> , [46:27]
|       |       |           |--EXPR -> EXPR [46:29]
|       |       |           |   `--NUM_FLOAT -> 1.2 [46:29]
|       |       |           `--RCURLY -> } [46:32]
|       |       |--SEMI -> ; [46:33]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [47:8]
|       |       |   |--MODIFIERS -> MODIFIERS [47:8]
|       |       |   |   `--FINAL -> final [47:8]
|       |       |   |--TYPE -> TYPE [47:14]
|       |       |   |   `--LITERAL_DOUBLE -> double [47:14]
|       |       |   |--IDENT -> dnZ [47:23]
|       |       |   `--ASSIGN -> = [47:27]
|       |       |       `--EXPR -> EXPR [47:56]
|       |       |           `--STAR -> * [47:56]
|       |       |               |--DOT -> . [47:33]
|       |       |               |   |--IDENT -> slot [47:29]
|       |       |               |   `--IDENT -> sin2Phi [47:34]
|       |       |               `--INDEX_OP -> [ [47:61]
|       |       |                   |--IDENT -> cZ [47:58]
|       |       |                   |--EXPR -> EXPR [47:62]
|       |       |                   |   `--NUM_INT -> 1 [47:62]
|       |       |                   `--RBRACK -> ] [47:63]
|       |       |--SEMI -> ; [47:64]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [49:8]
|       |       |   |--MODIFIERS -> MODIFIERS [49:8]
|       |       |   |   `--FINAL -> final [49:8]
|       |       |   |--TYPE -> TYPE [49:14]
|       |       |   |   `--IDENT -> Ef [49:14]
|       |       |   |--IDENT -> ef [49:17]
|       |       |   `--ASSIGN -> = [49:20]
|       |       |       `--EXPR -> EXPR [49:22]
|       |       |           `--LITERAL_NEW -> new [49:22]
|       |       |               |--IDENT -> Ef [49:26]
|       |       |               |--LPAREN -> ( [49:28]
|       |       |               |--ELIST -> ELIST [49:29]
|       |       |               `--RPAREN -> ) [49:29]
|       |       |--SEMI -> ; [49:30]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [50:8]
|       |       |   |--MODIFIERS -> MODIFIERS [50:8]
|       |       |   |   `--FINAL -> final [50:8]
|       |       |   |--TYPE -> TYPE [50:14]
|       |       |   |   `--IDENT -> Transformer [50:14]
|       |       |   |--IDENT -> transformer [50:26]
|       |       |   `--ASSIGN -> = [50:38]
|       |       |       `--EXPR -> EXPR [51:23]
|       |       |           `--QUESTION -> ? [51:23]
|       |       |               |--DOT -> . [51:14]
|       |       |               |   |--IDENT -> ef [51:12]
|       |       |               |   `--IDENT -> forward [51:15]
|       |       |               |--INDEX_OP -> [ [51:41]
|       |       |               |   |--DOT -> . [51:27]
|       |       |               |   |   |--IDENT -> ef [51:25]
|       |       |               |   |   `--IDENT -> transformers [51:28]
|       |       |               |   |--EXPR -> EXPR [51:65]
|       |       |               |   |   `--MINUS -> - [51:65]
|       |       |               |   |       |--DOT -> . [51:57]
|       |       |               |   |       |   |--DOT -> . [51:44]
|       |       |               |   |       |   |   |--IDENT -> ef [51:42]
|       |       |               |   |       |   |   `--IDENT -> transformers [51:45]
|       |       |               |   |       |   `--IDENT -> length [51:58]
|       |       |               |   |       `--NUM_INT -> 1 [51:67]
|       |       |               |   `--RBRACK -> ] [51:68]
|       |       |               |--COLON -> : [52:20]
|       |       |               `--INDEX_OP -> [ [52:38]
|       |       |                   |--DOT -> . [52:24]
|       |       |                   |   |--IDENT -> ef [52:22]
|       |       |                   |   `--IDENT -> transformers [52:25]
|       |       |                   |--EXPR -> EXPR [52:39]
|       |       |                   |   `--NUM_INT -> 0 [52:39]
|       |       |                   `--RBRACK -> ] [52:40]
|       |       |--SEMI -> ; [52:41]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [54:8]
|       |       |   |--MODIFIERS -> MODIFIERS [54:8]
|       |       |   |--TYPE -> TYPE [54:8]
|       |       |   |   |--LITERAL_INT -> int [54:8]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [54:11]
|       |       |   |   |   `--RBRACK -> ] [54:12]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [54:13]
|       |       |   |   |   `--RBRACK -> ] [55:16]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [57:18]
|       |       |   |   |   `--RBRACK -> ] [57:19]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [58:24]
|       |       |   |       `--RBRACK -> ] [58:25]
|       |       |   `--IDENT -> a [56:17]
|       |       |--SEMI -> ; [58:27]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [59:16]
|       |       |   |--MODIFIERS -> MODIFIERS [59:16]
|       |       |   |--TYPE -> TYPE [59:16]
|       |       |   |   |--LITERAL_INT -> int [59:16]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [59:19]
|       |       |   |   |   `--RBRACK -> ] [59:20]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [59:21]
|       |       |   |   |   `--RBRACK -> ] [60:17]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [62:17]
|       |       |   |   |   `--RBRACK -> ] [62:18]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [63:24]
|       |       |   |       `--RBRACK -> ] [63:25]
|       |       |   `--IDENT -> b [61:17]
|       |       |--SEMI -> ; [63:27]
|       |       `--RCURLY -> } [64:4]
|       |--METHOD_DEF -> METHOD_DEF [66:4]
|       |   |--MODIFIERS -> MODIFIERS [66:4]
|       |   |--TYPE -> TYPE [66:4]
|       |   |   `--LITERAL_VOID -> void [66:4]
|       |   |--IDENT -> varargLong [66:9]
|       |   |--LPAREN -> ( [66:19]
|       |   |--PARAMETERS -> PARAMETERS [66:20]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:20]
|       |   |       |--MODIFIERS -> MODIFIERS [66:20]
|       |   |       |   `--ANNOTATION -> ANNOTATION [66:20]
|       |   |       |       |--AT -> @ [66:20]
|       |   |       |       `--IDENT -> I [66:21]
|       |   |       |--TYPE -> TYPE [66:23]
|       |   |       |   |--IDENT -> String [66:23]
|       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [66:30]
|       |   |       |   |   `--ANNOTATION -> ANNOTATION [66:30]
|       |   |       |   |       |--AT -> @ [66:30]
|       |   |       |   |       `--IDENT -> L [66:31]
|       |   |       |   |--ARRAY_DECLARATOR -> [ [66:33]
|       |   |       |   |   `--RBRACK -> ] [66:34]
|       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [66:36]
|       |   |       |   |   `--ANNOTATION -> ANNOTATION [66:36]
|       |   |       |   |       |--AT -> @ [66:36]
|       |   |       |   |       `--IDENT -> K [66:37]
|       |   |       |   |--ARRAY_DECLARATOR -> [ [66:39]
|       |   |       |   |   `--RBRACK -> ] [66:40]
|       |   |       |   `--ANNOTATIONS -> ANNOTATIONS [66:42]
|       |   |       |       `--ANNOTATION -> ANNOTATION [66:42]
|       |   |       |           |--AT -> @ [66:42]
|       |   |       |           `--IDENT -> J [66:43]
|       |   |       |--ELLIPSIS -> ... [66:45]
|       |   |       `--IDENT -> vararg2 [66:49]
|       |   |--RPAREN -> ) [66:56]
|       |   `--SLIST -> { [66:58]
|       |       `--RCURLY -> } [66:60]
|       |--METHOD_DEF -> METHOD_DEF [67:4]
|       |   |--MODIFIERS -> MODIFIERS [67:4]
|       |   |   `--ANNOTATION -> ANNOTATION [67:4]
|       |   |       |--AT -> @ [67:4]
|       |   |       |--IDENT -> SuppressWarnings [67:5]
|       |   |       |--LPAREN -> ( [67:21]
|       |   |       |--EXPR -> EXPR [67:22]
|       |   |       |   `--STRING_LITERAL -> "unused" [67:22]
|       |   |       `--RPAREN -> ) [67:30]
|       |   |--TYPE -> TYPE [68:4]
|       |   |   `--LITERAL_VOID -> void [68:4]
|       |   |--IDENT -> withUpperBound [68:9]
|       |   |--LPAREN -> ( [68:23]
|       |   |--PARAMETERS -> PARAMETERS [68:24]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [68:24]
|       |   |       |--MODIFIERS -> MODIFIERS [68:24]
|       |   |       |--TYPE -> TYPE [68:24]
|       |   |       |   |--IDENT -> List [68:24]
|       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [68:28]
|       |   |       |       |--GENERIC_START -> < [68:28]
|       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [68:29]
|       |   |       |       |   |--WILDCARD_TYPE -> ? [68:29]
|       |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [68:31]
|       |   |       |       |       |--LITERAL_INT -> int [68:39]
|       |   |       |       |       |--ARRAY_DECLARATOR -> [ [68:42]
|       |   |       |       |       |   `--RBRACK -> ] [68:43]
|       |   |       |       |       `--ARRAY_DECLARATOR -> [ [68:44]
|       |   |       |       |           `--RBRACK -> ] [68:45]
|       |   |       |       `--GENERIC_END -> > [68:46]
|       |   |       `--IDENT -> list [68:48]
|       |   |--RPAREN -> ) [68:52]
|       |   `--SLIST -> { [68:54]
|       |       `--RCURLY -> } [68:55]
|       |--CLASS_DEF -> CLASS_DEF [70:4]
|       |   |--MODIFIERS -> MODIFIERS [70:4]
|       |   |   |--LITERAL_PRIVATE -> private [70:4]
|       |   |   `--LITERAL_STATIC -> static [70:12]
|       |   |--LITERAL_CLASS -> class [70:19]
|       |   |--IDENT -> SSLSecurity [70:25]
|       |   `--OBJBLOCK -> OBJBLOCK [70:37]
|       |       |--LCURLY -> { [70:37]
|       |       |--METHOD_DEF -> METHOD_DEF [71:8]
|       |       |   |--MODIFIERS -> MODIFIERS [71:8]
|       |       |   |   `--LITERAL_STATIC -> static [71:8]
|       |       |   |--TYPE -> TYPE [71:15]
|       |       |   |   |--IDENT -> KeyManager [71:15]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [71:25]
|       |       |   |       `--RBRACK -> ] [71:26]
|       |       |   |--IDENT -> truncateArray [71:28]
|       |       |   |--LPAREN -> ( [71:41]
|       |       |   |--PARAMETERS -> PARAMETERS [71:42]
|       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [71:42]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [71:42]
|       |       |   |   |   |--TYPE -> TYPE [71:42]
|       |       |   |   |   |   |--IDENT -> KeyManager [71:42]
|       |       |   |   |   |   `--ARRAY_DECLARATOR -> [ [71:52]
|       |       |   |   |   |       `--RBRACK -> ] [71:53]
|       |       |   |   |   `--IDENT -> kmaw [71:55]
|       |       |   |   |--COMMA -> , [71:59]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [72:42]
|       |       |   |       |--MODIFIERS -> MODIFIERS [72:42]
|       |       |   |       |--TYPE -> TYPE [72:42]
|       |       |   |       |   |--IDENT -> KeyManager [72:42]
|       |       |   |       |   `--ARRAY_DECLARATOR -> [ [72:52]
|       |       |   |       |       `--RBRACK -> ] [72:53]
|       |       |   |       `--IDENT -> keyManagers [72:55]
|       |       |   |--RPAREN -> ) [72:66]
|       |       |   `--SLIST -> { [72:68]
|       |       |       |--LITERAL_RETURN -> return [73:12]
|       |       |       |   |--EXPR -> EXPR [73:19]
|       |       |       |   |   `--LITERAL_NULL -> null [73:19]
|       |       |       |   `--SEMI -> ; [73:23]
|       |       |       `--RCURLY -> } [74:8]
|       |       `--RCURLY -> } [75:4]
|       |--METHOD_DEF -> METHOD_DEF [78:4]
|       |   |--MODIFIERS -> MODIFIERS [78:4]
|       |   |--TYPE -> TYPE [78:4]
|       |   |   `--LITERAL_VOID -> void [78:4]
|       |   |--IDENT -> method3 [78:9]
|       |   |--LPAREN -> ( [78:16]
|       |   |--PARAMETERS -> PARAMETERS [78:17]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [78:17]
|       |   |       |--MODIFIERS -> MODIFIERS [78:17]
|       |   |       |--TYPE -> TYPE [78:17]
|       |   |       |   `--LITERAL_INT -> int [78:17]
|       |   |       `--IDENT -> x [78:21]
|       |   |--RPAREN -> ) [78:22]
|       |   `--SLIST -> { [78:24]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [79:8]
|       |       |   |--MODIFIERS -> MODIFIERS [79:8]
|       |       |   |--TYPE -> TYPE [79:8]
|       |       |   |   |--IDENT -> KeyManager [79:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [79:18]
|       |       |   |       `--RBRACK -> ] [79:19]
|       |       |   |--IDENT -> kmaw [79:21]
|       |       |   `--ASSIGN -> = [79:26]
|       |       |       `--EXPR -> EXPR [79:28]
|       |       |           `--LITERAL_NULL -> null [79:28]
|       |       |--SEMI -> ; [79:32]
|       |       |--LITERAL_IF -> if [80:9]
|       |       |   |--LPAREN -> ( [80:12]
|       |       |   |--EXPR -> EXPR [80:15]
|       |       |   |   `--EQUAL -> == [80:15]
|       |       |   |       |--IDENT -> x [80:13]
|       |       |   |       `--NUM_INT -> 1 [80:18]
|       |       |   |--RPAREN -> ) [80:19]
|       |       |   `--SLIST -> { [80:21]
|       |       |       |--EXPR -> EXPR [81:18]
|       |       |       |   `--ASSIGN -> = [81:18]
|       |       |       |       |--IDENT -> kmaw [81:13]
|       |       |       |       `--TYPECAST -> ( [81:20]
|       |       |       |           |--TYPE -> TYPE [81:34]
|       |       |       |           |   |--DOT -> . [81:34]
|       |       |       |           |   |   |--DOT -> . [81:30]
|       |       |       |           |   |   |   |--DOT -> . [81:26]
|       |       |       |           |   |   |   |   |--IDENT -> javax [81:21]
|       |       |       |           |   |   |   |   `--IDENT -> net [81:27]
|       |       |       |           |   |   |   `--IDENT -> ssl [81:31]
|       |       |       |           |   |   `--IDENT -> KeyManager [81:35]
|       |       |       |           |   `--ARRAY_DECLARATOR -> [ [81:45]
|       |       |       |           |       `--RBRACK -> ] [81:46]
|       |       |       |           |--RPAREN -> ) [81:47]
|       |       |       |           `--METHOD_CALL -> ( [82:48]
|       |       |       |               |--DOT -> . [82:34]
|       |       |       |               |   |--IDENT -> SSLSecurity [82:23]
|       |       |       |               |   `--IDENT -> truncateArray [82:35]
|       |       |       |               |--ELIST -> ELIST [82:49]
|       |       |       |               |   |--EXPR -> EXPR [82:49]
|       |       |       |               |   |   `--IDENT -> kmaw [82:49]
|       |       |       |               |   |--COMMA -> , [82:53]
|       |       |       |               |   `--EXPR -> EXPR [83:27]
|       |       |       |               |       `--LITERAL_NEW -> new [83:27]
|       |       |       |               |           |--DOT -> . [83:44]
|       |       |       |               |           |   |--DOT -> . [83:40]
|       |       |       |               |           |   |   |--DOT -> . [83:36]
|       |       |       |               |           |   |   |   |--IDENT -> javax [83:31]
|       |       |       |               |           |   |   |   `--IDENT -> net [83:37]
|       |       |       |               |           |   |   `--IDENT -> ssl [83:41]
|       |       |       |               |           |   `--IDENT -> KeyManager [83:45]
|       |       |       |               |           `--ARRAY_DECLARATOR -> [ [83:56]
|       |       |       |               |               |--EXPR -> EXPR [83:57]
|       |       |       |               |               |   `--NUM_INT -> 3 [83:57]
|       |       |       |               |               `--RBRACK -> ] [83:58]
|       |       |       |               `--RPAREN -> ) [83:59]
|       |       |       |--SEMI -> ; [83:60]
|       |       |       `--RCURLY -> } [84:9]
|       |       `--RCURLY -> } [85:4]
|       |--ENUM_DEF -> ENUM_DEF [87:4]
|       |   |--MODIFIERS -> MODIFIERS [87:4]
|       |   |--ENUM -> enum [87:4]
|       |   |--IDENT -> FPMethodArgs [87:9]
|       |   `--OBJBLOCK -> OBJBLOCK [87:22]
|       |       |--LCURLY -> { [87:22]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [89:8]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [89:8]
|       |       |   `--IDENT -> IGNN [89:8]
|       |       |--COMMA -> , [89:12]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [90:8]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [90:8]
|       |       |   `--IDENT -> IIGNN [90:8]
|       |       |--COMMA -> , [90:13]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [91:8]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [91:8]
|       |       |   `--IDENT -> GNNII [91:8]
|       |       |--COMMA -> , [91:13]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [92:8]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [92:8]
|       |       |   `--IDENT -> GNNC [92:8]
|       |       |--SEMI -> ; [92:12]
|       |       |--METHOD_DEF -> METHOD_DEF [94:8]
|       |       |   |--MODIFIERS -> MODIFIERS [94:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [94:8]
|       |       |   |--TYPE -> TYPE [94:15]
|       |       |   |   |--IDENT -> Class [94:15]
|       |       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [94:20]
|       |       |   |   |   |--GENERIC_START -> < [94:20]
|       |       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [94:21]
|       |       |   |   |   |   `--WILDCARD_TYPE -> ? [94:21]
|       |       |   |   |   `--GENERIC_END -> > [94:22]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [94:23]
|       |       |   |       `--RBRACK -> ] [94:24]
|       |       |   |--IDENT -> getMethodArguments [94:26]
|       |       |   |--LPAREN -> ( [94:44]
|       |       |   |--PARAMETERS -> PARAMETERS [94:45]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [94:45]
|       |       |   |       |--MODIFIERS -> MODIFIERS [94:45]
|       |       |   |       |--TYPE -> TYPE [94:45]
|       |       |   |       |   `--LITERAL_BOOLEAN -> boolean [94:45]
|       |       |   |       `--IDENT -> isFPType [94:53]
|       |       |   |--RPAREN -> ) [94:61]
|       |       |   `--SLIST -> { [94:63]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [95:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [95:12]
|       |       |       |   |--TYPE -> TYPE [95:12]
|       |       |       |   |   |--IDENT -> Class [95:12]
|       |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [95:17]
|       |       |       |   |       |--GENERIC_START -> < [95:17]
|       |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [95:18]
|       |       |       |   |       |   `--WILDCARD_TYPE -> ? [95:18]
|       |       |       |   |       `--GENERIC_END -> > [95:19]
|       |       |       |   |--IDENT -> N [95:21]
|       |       |       |   `--ASSIGN -> = [95:23]
|       |       |       |       `--EXPR -> EXPR [95:36]
|       |       |       |           `--QUESTION -> ? [95:36]
|       |       |       |               |--LPAREN -> ( [95:25]
|       |       |       |               |--IDENT -> isFPType [95:26]
|       |       |       |               |--RPAREN -> ) [95:34]
|       |       |       |               |--DOT -> . [95:43]
|       |       |       |               |   |--IDENT -> Float [95:38]
|       |       |       |               |   `--IDENT -> TYPE [95:44]
|       |       |       |               |--COLON -> : [95:49]
|       |       |       |               `--DOT -> . [95:58]
|       |       |       |                   |--IDENT -> Integer [95:51]
|       |       |       |                   `--IDENT -> TYPE [95:59]
|       |       |       |--SEMI -> ; [95:63]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [96:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [96:12]
|       |       |       |   |--TYPE -> TYPE [96:12]
|       |       |       |   |   |--IDENT -> Class [96:12]
|       |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [96:17]
|       |       |       |   |       |--GENERIC_START -> < [96:17]
|       |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [96:18]
|       |       |       |   |       |   `--WILDCARD_TYPE -> ? [96:18]
|       |       |       |   |       `--GENERIC_END -> > [96:19]
|       |       |       |   |--IDENT -> G [96:21]
|       |       |       |   `--ASSIGN -> = [96:23]
|       |       |       |       `--EXPR -> EXPR [96:36]
|       |       |       |           `--QUESTION -> ? [96:36]
|       |       |       |               |--LPAREN -> ( [96:25]
|       |       |       |               |--IDENT -> isFPType [96:26]
|       |       |       |               |--RPAREN -> ) [96:34]
|       |       |       |               |--DOT -> . [96:48]
|       |       |       |               |   |--IDENT -> Graphics2D [96:38]
|       |       |       |               |   `--LITERAL_CLASS -> class [96:49]
|       |       |       |               |--COLON -> : [96:55]
|       |       |       |               `--DOT -> . [96:65]
|       |       |       |                   |--IDENT -> Graphics [96:57]
|       |       |       |                   `--LITERAL_CLASS -> class [96:66]
|       |       |       |--SEMI -> ; [96:71]
|       |       |       |--LITERAL_SWITCH -> switch [97:12]
|       |       |       |   |--LPAREN -> ( [97:19]
|       |       |       |   |--EXPR -> EXPR [97:20]
|       |       |       |   |   `--LITERAL_THIS -> this [97:20]
|       |       |       |   |--RPAREN -> ) [97:24]
|       |       |       |   |--LCURLY -> { [97:26]
|       |       |       |   |--CASE_GROUP -> CASE_GROUP [98:16]
|       |       |       |   |   |--LITERAL_CASE -> case [98:16]
|       |       |       |   |   |   |--EXPR -> EXPR [98:21]
|       |       |       |   |   |   |   `--IDENT -> IGNN [98:21]
|       |       |       |   |   |   `--COLON -> : [98:25]
|       |       |       |   |   `--SLIST -> SLIST [99:20]
|       |       |       |   |       `--LITERAL_RETURN -> return [99:20]
|       |       |       |   |           |--EXPR -> EXPR [99:27]
|       |       |       |   |           |   `--LITERAL_NEW -> new [99:27]
|       |       |       |   |           |       |--IDENT -> Class [99:31]
|       |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [99:36]
|       |       |       |   |           |       |   |--GENERIC_START -> < [99:36]
|       |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [99:37]
|       |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [99:37]
|       |       |       |   |           |       |   `--GENERIC_END -> > [99:38]
|       |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [99:39]
|       |       |       |   |           |       |   `--RBRACK -> ] [99:40]
|       |       |       |   |           |       `--ARRAY_INIT -> { [99:41]
|       |       |       |   |           |           |--EXPR -> EXPR [99:49]
|       |       |       |   |           |           |   `--DOT -> . [99:49]
|       |       |       |   |           |           |       |--IDENT -> Integer [99:42]
|       |       |       |   |           |           |       `--IDENT -> TYPE [99:50]
|       |       |       |   |           |           |--COMMA -> , [99:54]
|       |       |       |   |           |           |--EXPR -> EXPR [99:56]
|       |       |       |   |           |           |   `--IDENT -> G [99:56]
|       |       |       |   |           |           |--COMMA -> , [99:57]
|       |       |       |   |           |           |--EXPR -> EXPR [99:59]
|       |       |       |   |           |           |   `--IDENT -> N [99:59]
|       |       |       |   |           |           |--COMMA -> , [99:60]
|       |       |       |   |           |           |--EXPR -> EXPR [99:62]
|       |       |       |   |           |           |   `--IDENT -> N [99:62]
|       |       |       |   |           |           `--RCURLY -> } [99:63]
|       |       |       |   |           `--SEMI -> ; [99:64]
|       |       |       |   |--CASE_GROUP -> CASE_GROUP [100:16]
|       |       |       |   |   |--LITERAL_CASE -> case [100:16]
|       |       |       |   |   |   |--EXPR -> EXPR [100:21]
|       |       |       |   |   |   |   `--IDENT -> IIGNN [100:21]
|       |       |       |   |   |   `--COLON -> : [100:26]
|       |       |       |   |   `--SLIST -> SLIST [101:20]
|       |       |       |   |       `--LITERAL_RETURN -> return [101:20]
|       |       |       |   |           |--EXPR -> EXPR [101:27]
|       |       |       |   |           |   `--LITERAL_NEW -> new [101:27]
|       |       |       |   |           |       |--IDENT -> Class [101:31]
|       |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [101:36]
|       |       |       |   |           |       |   |--GENERIC_START -> < [101:36]
|       |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [101:37]
|       |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [101:37]
|       |       |       |   |           |       |   `--GENERIC_END -> > [101:38]
|       |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [101:39]
|       |       |       |   |           |       |   `--RBRACK -> ] [101:40]
|       |       |       |   |           |       `--ARRAY_INIT -> { [101:41]
|       |       |       |   |           |           |--EXPR -> EXPR [101:49]
|       |       |       |   |           |           |   `--DOT -> . [101:49]
|       |       |       |   |           |           |       |--IDENT -> Integer [101:42]
|       |       |       |   |           |           |       `--IDENT -> TYPE [101:50]
|       |       |       |   |           |           |--COMMA -> , [101:54]
|       |       |       |   |           |           |--EXPR -> EXPR [101:63]
|       |       |       |   |           |           |   `--DOT -> . [101:63]
|       |       |       |   |           |           |       |--IDENT -> Integer [101:56]
|       |       |       |   |           |           |       `--IDENT -> TYPE [101:64]
|       |       |       |   |           |           |--COMMA -> , [101:68]
|       |       |       |   |           |           |--EXPR -> EXPR [101:70]
|       |       |       |   |           |           |   `--IDENT -> G [101:70]
|       |       |       |   |           |           |--COMMA -> , [101:71]
|       |       |       |   |           |           |--EXPR -> EXPR [101:73]
|       |       |       |   |           |           |   `--IDENT -> N [101:73]
|       |       |       |   |           |           |--COMMA -> , [101:74]
|       |       |       |   |           |           |--EXPR -> EXPR [101:76]
|       |       |       |   |           |           |   `--IDENT -> N [101:76]
|       |       |       |   |           |           `--RCURLY -> } [101:77]
|       |       |       |   |           `--SEMI -> ; [101:78]
|       |       |       |   |--CASE_GROUP -> CASE_GROUP [102:16]
|       |       |       |   |   |--LITERAL_CASE -> case [102:16]
|       |       |       |   |   |   |--EXPR -> EXPR [102:21]
|       |       |       |   |   |   |   `--IDENT -> GNNII [102:21]
|       |       |       |   |   |   `--COLON -> : [102:26]
|       |       |       |   |   `--SLIST -> SLIST [103:20]
|       |       |       |   |       `--LITERAL_RETURN -> return [103:20]
|       |       |       |   |           |--EXPR -> EXPR [103:27]
|       |       |       |   |           |   `--LITERAL_NEW -> new [103:27]
|       |       |       |   |           |       |--IDENT -> Class [103:31]
|       |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [103:36]
|       |       |       |   |           |       |   |--GENERIC_START -> < [103:36]
|       |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [103:37]
|       |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [103:37]
|       |       |       |   |           |       |   `--GENERIC_END -> > [103:38]
|       |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [103:39]
|       |       |       |   |           |       |   `--RBRACK -> ] [103:40]
|       |       |       |   |           |       `--ARRAY_INIT -> { [103:41]
|       |       |       |   |           |           |--EXPR -> EXPR [103:42]
|       |       |       |   |           |           |   `--IDENT -> G [103:42]
|       |       |       |   |           |           |--COMMA -> , [103:43]
|       |       |       |   |           |           |--EXPR -> EXPR [103:45]
|       |       |       |   |           |           |   `--IDENT -> N [103:45]
|       |       |       |   |           |           |--COMMA -> , [103:46]
|       |       |       |   |           |           |--EXPR -> EXPR [103:48]
|       |       |       |   |           |           |   `--IDENT -> N [103:48]
|       |       |       |   |           |           |--COMMA -> , [103:49]
|       |       |       |   |           |           |--EXPR -> EXPR [103:58]
|       |       |       |   |           |           |   `--DOT -> . [103:58]
|       |       |       |   |           |           |       |--IDENT -> Integer [103:51]
|       |       |       |   |           |           |       `--IDENT -> TYPE [103:59]
|       |       |       |   |           |           |--COMMA -> , [103:63]
|       |       |       |   |           |           |--EXPR -> EXPR [103:72]
|       |       |       |   |           |           |   `--DOT -> . [103:72]
|       |       |       |   |           |           |       |--IDENT -> Integer [103:65]
|       |       |       |   |           |           |       `--IDENT -> TYPE [103:73]
|       |       |       |   |           |           `--RCURLY -> } [103:77]
|       |       |       |   |           `--SEMI -> ; [103:78]
|       |       |       |   |--CASE_GROUP -> CASE_GROUP [104:16]
|       |       |       |   |   |--LITERAL_CASE -> case [104:16]
|       |       |       |   |   |   |--EXPR -> EXPR [104:21]
|       |       |       |   |   |   |   `--IDENT -> GNNC [104:21]
|       |       |       |   |   |   `--COLON -> : [104:25]
|       |       |       |   |   `--SLIST -> SLIST [105:20]
|       |       |       |   |       `--LITERAL_RETURN -> return [105:20]
|       |       |       |   |           |--EXPR -> EXPR [105:27]
|       |       |       |   |           |   `--LITERAL_NEW -> new [105:27]
|       |       |       |   |           |       |--IDENT -> Class [105:31]
|       |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [105:36]
|       |       |       |   |           |       |   |--GENERIC_START -> < [105:36]
|       |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [105:37]
|       |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [105:37]
|       |       |       |   |           |       |   `--GENERIC_END -> > [105:38]
|       |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [105:39]
|       |       |       |   |           |       |   `--RBRACK -> ] [105:40]
|       |       |       |   |           |       `--ARRAY_INIT -> { [105:41]
|       |       |       |   |           |           |--EXPR -> EXPR [105:42]
|       |       |       |   |           |           |   `--IDENT -> G [105:42]
|       |       |       |   |           |           |--COMMA -> , [105:43]
|       |       |       |   |           |           |--EXPR -> EXPR [105:45]
|       |       |       |   |           |           |   `--IDENT -> N [105:45]
|       |       |       |   |           |           |--COMMA -> , [105:46]
|       |       |       |   |           |           |--EXPR -> EXPR [105:48]
|       |       |       |   |           |           |   `--IDENT -> N [105:48]
|       |       |       |   |           |           |--COMMA -> , [105:49]
|       |       |       |   |           |           |--EXPR -> EXPR [105:60]
|       |       |       |   |           |           |   `--DOT -> . [105:60]
|       |       |       |   |           |           |       |--IDENT -> Character [105:51]
|       |       |       |   |           |           |       `--IDENT -> TYPE [105:61]
|       |       |       |   |           |           `--RCURLY -> } [105:65]
|       |       |       |   |           `--SEMI -> ; [105:66]
|       |       |       |   |--CASE_GROUP -> CASE_GROUP [106:16]
|       |       |       |   |   |--LITERAL_DEFAULT -> default [106:16]
|       |       |       |   |   |   `--COLON -> : [106:23]
|       |       |       |   |   `--SLIST -> SLIST [107:20]
|       |       |       |   |       `--LITERAL_THROW -> throw [107:20]
|       |       |       |   |           |--EXPR -> EXPR [107:26]
|       |       |       |   |           |   `--LITERAL_NEW -> new [107:26]
|       |       |       |   |           |       |--IDENT -> RuntimeException [107:30]
|       |       |       |   |           |       |--LPAREN -> ( [107:46]
|       |       |       |   |           |       |--ELIST -> ELIST [107:47]
|       |       |       |   |           |       |   `--EXPR -> EXPR [107:47]
|       |       |       |   |           |       |       `--STRING_LITERAL -> "Unknown method arguments!" [107:47]
|       |       |       |   |           |       `--RPAREN -> ) [107:74]
|       |       |       |   |           `--SEMI -> ; [107:75]
|       |       |       |   `--RCURLY -> } [108:12]
|       |       |       `--RCURLY -> } [109:8]
|       |       `--RCURLY -> } [110:4]
|       |--CLASS_DEF -> CLASS_DEF [112:4]
|       |   |--MODIFIERS -> MODIFIERS [112:4]
|       |   |   |--LITERAL_PUBLIC -> public [112:4]
|       |   |   `--LITERAL_STATIC -> static [112:11]
|       |   |--LITERAL_CLASS -> class [112:18]
|       |   |--IDENT -> IntData [112:24]
|       |   `--OBJBLOCK -> OBJBLOCK [112:32]
|       |       |--LCURLY -> { [112:32]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
|       |       |   |--MODIFIERS -> MODIFIERS [113:8]
|       |       |   |--TYPE -> TYPE [113:8]
|       |       |   |   |--LITERAL_INT -> int [113:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [113:11]
|       |       |   |       `--RBRACK -> ] [113:12]
|       |       |   |--IDENT -> xorData [113:14]
|       |       |   `--SEMI -> ; [113:21]
|       |       |--CTOR_DEF -> CTOR_DEF [115:8]
|       |       |   |--MODIFIERS -> MODIFIERS [115:8]
|       |       |   |--IDENT -> IntData [115:8]
|       |       |   |--LPAREN -> ( [115:15]
|       |       |   |--PARAMETERS -> PARAMETERS [115:16]
|       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [115:16]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [115:16]
|       |       |   |   |   |--TYPE -> TYPE [115:16]
|       |       |   |   |   |   `--IDENT -> Object [115:16]
|       |       |   |   |   `--IDENT -> srcPixel [115:23]
|       |       |   |   |--COMMA -> , [115:31]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [115:33]
|       |       |   |       |--MODIFIERS -> MODIFIERS [115:33]
|       |       |   |       |--TYPE -> TYPE [115:33]
|       |       |   |       |   `--IDENT -> Object [115:33]
|       |       |   |       `--IDENT -> xorPixel [115:40]
|       |       |   |--RPAREN -> ) [115:48]
|       |       |   `--SLIST -> { [115:50]
|       |       |       |--EXPR -> EXPR [116:25]
|       |       |       |   `--ASSIGN -> = [116:25]
|       |       |       |       |--DOT -> . [116:16]
|       |       |       |       |   |--LITERAL_THIS -> this [116:12]
|       |       |       |       |   `--IDENT -> xorData [116:17]
|       |       |       |       `--TYPECAST -> ( [116:27]
|       |       |       |           |--TYPE -> TYPE [116:28]
|       |       |       |           |   |--LITERAL_INT -> int [116:28]
|       |       |       |           |   `--ARRAY_DECLARATOR -> [ [116:31]
|       |       |       |           |       `--RBRACK -> ] [116:32]
|       |       |       |           |--RPAREN -> ) [116:33]
|       |       |       |           `--IDENT -> srcPixel [116:35]
|       |       |       |--SEMI -> ; [116:43]
|       |       |       |--EXPR -> EXPR [117:25]
|       |       |       |   `--ASSIGN -> = [117:25]
|       |       |       |       |--DOT -> . [117:16]
|       |       |       |       |   |--LITERAL_THIS -> this [117:12]
|       |       |       |       |   `--IDENT -> xorData [117:17]
|       |       |       |       `--TYPECAST -> ( [117:27]
|       |       |       |           |--TYPE -> TYPE [117:28]
|       |       |       |           |   |--LITERAL_INT -> int [117:28]
|       |       |       |           |   `--ARRAY_DECLARATOR -> [ [117:31]
|       |       |       |           |       `--RBRACK -> ] [117:32]
|       |       |       |           |--RPAREN -> ) [117:33]
|       |       |       |           `--IDENT -> xorPixel [117:35]
|       |       |       |--SEMI -> ; [117:43]
|       |       |       `--RCURLY -> } [118:8]
|       |       |--METHOD_DEF -> METHOD_DEF [120:8]
|       |       |   |--MODIFIERS -> MODIFIERS [120:8]
|       |       |   |   `--LITERAL_PROTECTED -> protected [120:8]
|       |       |   |--TYPE -> TYPE [120:18]
|       |       |   |   `--LITERAL_VOID -> void [120:18]
|       |       |   |--IDENT -> xorPixel [120:23]
|       |       |   |--LPAREN -> ( [120:31]
|       |       |   |--PARAMETERS -> PARAMETERS [120:32]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [120:32]
|       |       |   |       |--MODIFIERS -> MODIFIERS [120:32]
|       |       |   |       |--TYPE -> TYPE [120:32]
|       |       |   |       |   `--IDENT -> Object [120:32]
|       |       |   |       `--IDENT -> pixData [120:39]
|       |       |   |--RPAREN -> ) [120:46]
|       |       |   `--SLIST -> { [120:48]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [121:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [121:12]
|       |       |       |   |--TYPE -> TYPE [121:12]
|       |       |       |   |   |--LITERAL_INT -> int [121:12]
|       |       |       |   |   `--ARRAY_DECLARATOR -> [ [121:15]
|       |       |       |   |       `--RBRACK -> ] [121:16]
|       |       |       |   |--IDENT -> dstData [121:18]
|       |       |       |   `--ASSIGN -> = [121:26]
|       |       |       |       `--EXPR -> EXPR [121:28]
|       |       |       |           `--TYPECAST -> ( [121:28]
|       |       |       |               |--TYPE -> TYPE [121:29]
|       |       |       |               |   |--LITERAL_INT -> int [121:29]
|       |       |       |               |   `--ARRAY_DECLARATOR -> [ [121:32]
|       |       |       |               |       `--RBRACK -> ] [121:33]
|       |       |       |               |--RPAREN -> ) [121:34]
|       |       |       |               `--IDENT -> pixData [121:36]
|       |       |       |--SEMI -> ; [121:43]
|       |       |       |--LITERAL_FOR -> for [122:12]
|       |       |       |   |--LPAREN -> ( [122:16]
|       |       |       |   |--FOR_INIT -> FOR_INIT [122:17]
|       |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [122:17]
|       |       |       |   |       |--MODIFIERS -> MODIFIERS [122:17]
|       |       |       |   |       |--TYPE -> TYPE [122:17]
|       |       |       |   |       |   `--LITERAL_INT -> int [122:17]
|       |       |       |   |       |--IDENT -> i [122:21]
|       |       |       |   |       `--ASSIGN -> = [122:23]
|       |       |       |   |           `--EXPR -> EXPR [122:25]
|       |       |       |   |               `--NUM_INT -> 0 [122:25]
|       |       |       |   |--SEMI -> ; [122:26]
|       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [122:30]
|       |       |       |   |   `--EXPR -> EXPR [122:30]
|       |       |       |   |       `--LT -> < [122:30]
|       |       |       |   |           |--IDENT -> i [122:28]
|       |       |       |   |           `--DOT -> . [122:39]
|       |       |       |   |               |--IDENT -> dstData [122:32]
|       |       |       |   |               `--IDENT -> length [122:40]
|       |       |       |   |--SEMI -> ; [122:46]
|       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [122:49]
|       |       |       |   |   `--ELIST -> ELIST [122:49]
|       |       |       |   |       `--EXPR -> EXPR [122:49]
|       |       |       |   |           `--POST_INC -> ++ [122:49]
|       |       |       |   |               `--IDENT -> i [122:48]
|       |       |       |   |--RPAREN -> ) [122:51]
|       |       |       |   `--SLIST -> { [122:53]
|       |       |       |       |--EXPR -> EXPR [123:27]
|       |       |       |       |   `--BXOR_ASSIGN -> ^= [123:27]
|       |       |       |       |       |--INDEX_OP -> [ [123:23]
|       |       |       |       |       |   |--IDENT -> dstData [123:16]
|       |       |       |       |       |   |--EXPR -> EXPR [123:24]
|       |       |       |       |       |   |   `--IDENT -> i [123:24]
|       |       |       |       |       |   `--RBRACK -> ] [123:25]
|       |       |       |       |       `--INDEX_OP -> [ [123:37]
|       |       |       |       |           |--IDENT -> xorData [123:30]
|       |       |       |       |           |--EXPR -> EXPR [123:38]
|       |       |       |       |           |   `--IDENT -> i [123:38]
|       |       |       |       |           `--RBRACK -> ] [123:39]
|       |       |       |       |--SEMI -> ; [123:40]
|       |       |       |       `--RCURLY -> } [124:12]
|       |       |       `--RCURLY -> } [125:8]
|       |       |--METHOD_DEF -> METHOD_DEF [127:8]
|       |       |   |--MODIFIERS -> MODIFIERS [127:8]
|       |       |   |--TYPE -> TYPE [127:8]
|       |       |   |   |--IDENT -> Object [127:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [127:14]
|       |       |   |       `--RBRACK -> ] [127:15]
|       |       |   |--IDENT -> getXorData [127:17]
|       |       |   |--LPAREN -> ( [127:27]
|       |       |   |--PARAMETERS -> PARAMETERS [127:28]
|       |       |   |--RPAREN -> ) [127:28]
|       |       |   `--SLIST -> { [127:30]
|       |       |       |--LITERAL_RETURN -> return [128:12]
|       |       |       |   |--EXPR -> EXPR [128:19]
|       |       |       |   |   `--LITERAL_NEW -> new [128:19]
|       |       |       |   |       |--IDENT -> Object [128:23]
|       |       |       |   |       `--ARRAY_DECLARATOR -> [ [128:29]
|       |       |       |   |           |--EXPR -> EXPR [128:30]
|       |       |       |   |           |   `--NUM_INT -> 5 [128:30]
|       |       |       |   |           `--RBRACK -> ] [128:31]
|       |       |       |   `--SEMI -> ; [128:32]
|       |       |       `--RCURLY -> } [129:8]
|       |       |--METHOD_DEF -> METHOD_DEF [131:8]
|       |       |   |--MODIFIERS -> MODIFIERS [131:8]
|       |       |   |--TYPE -> TYPE [131:8]
|       |       |   |   `--LITERAL_VOID -> void [131:8]
|       |       |   |--IDENT -> method6 [131:13]
|       |       |   |--LPAREN -> ( [131:20]
|       |       |   |--PARAMETERS -> PARAMETERS [131:21]
|       |       |   |--RPAREN -> ) [131:21]
|       |       |   `--SLIST -> { [131:23]
|       |       |       |--LITERAL_IF -> if [132:12]
|       |       |       |   |--LPAREN -> ( [132:15]
|       |       |       |   |--EXPR -> EXPR [134:20]
|       |       |       |   |   `--LOR -> || [134:20]
|       |       |       |   |       |--LAND -> && [133:20]
|       |       |       |   |       |   |--EQUAL -> == [132:36]
|       |       |       |   |       |   |   |--DOT -> . [132:28]
|       |       |       |   |       |   |   |   |--METHOD_CALL -> ( [132:26]
|       |       |       |   |       |   |   |   |   |--IDENT -> getXorData [132:16]
|       |       |       |   |       |   |   |   |   |--ELIST -> ELIST [132:27]
|       |       |       |   |       |   |   |   |   `--RPAREN -> ) [132:27]
|       |       |       |   |       |   |   |   `--IDENT -> length [132:29]
|       |       |       |   |       |   |   `--NUM_INT -> 5 [132:39]
|       |       |       |   |       |   `--NOT_EQUAL -> != [133:44]
|       |       |       |   |       |       |--INDEX_OP -> [ [133:40]
|       |       |       |   |       |       |   |--METHOD_CALL -> ( [133:38]
|       |       |       |   |       |       |   |   |--DOT -> . [133:27]
|       |       |       |   |       |       |   |   |   |--LITERAL_THIS -> this [133:23]
|       |       |       |   |       |       |   |   |   `--IDENT -> getXorData [133:28]
|       |       |       |   |       |       |   |   |--ELIST -> ELIST [133:39]
|       |       |       |   |       |       |   |   `--RPAREN -> ) [133:39]
|       |       |       |   |       |       |   |--EXPR -> EXPR [133:41]
|       |       |       |   |       |       |   |   `--NUM_INT -> 1 [133:41]
|       |       |       |   |       |       |   `--RBRACK -> ] [133:42]
|       |       |       |   |       |       `--DOT -> . [133:54]
|       |       |       |   |       |           |--IDENT -> IntData [133:47]
|       |       |       |   |       |           `--LITERAL_CLASS -> class [133:55]
|       |       |       |   |       `--NOT_EQUAL -> != [134:44]
|       |       |       |   |           |--INDEX_OP -> [ [134:40]
|       |       |       |   |           |   |--METHOD_CALL -> ( [134:38]
|       |       |       |   |           |   |   |--DOT -> . [134:27]
|       |       |       |   |           |   |   |   |--LITERAL_THIS -> this [134:23]
|       |       |       |   |           |   |   |   `--IDENT -> getXorData [134:28]
|       |       |       |   |           |   |   |--ELIST -> ELIST [134:39]
|       |       |       |   |           |   |   `--RPAREN -> ) [134:39]
|       |       |       |   |           |   |--EXPR -> EXPR [134:41]
|       |       |       |   |           |   |   `--NUM_INT -> 5 [134:41]
|       |       |       |   |           |   `--RBRACK -> ] [134:42]
|       |       |       |   |           `--DOT -> . [134:54]
|       |       |       |   |               |--IDENT -> IntData [134:47]
|       |       |       |   |               `--LITERAL_CLASS -> class [134:55]
|       |       |       |   |--RPAREN -> ) [134:60]
|       |       |       |   `--SLIST -> { [134:62]
|       |       |       |       |--EXPR -> EXPR [135:34]
|       |       |       |       |   `--METHOD_CALL -> ( [135:34]
|       |       |       |       |       |--DOT -> . [135:26]
|       |       |       |       |       |   |--DOT -> . [135:22]
|       |       |       |       |       |   |   |--IDENT -> System [135:16]
|       |       |       |       |       |   |   `--IDENT -> out [135:23]
|       |       |       |       |       |   `--IDENT -> println [135:27]
|       |       |       |       |       |--ELIST -> ELIST [135:47]
|       |       |       |       |       |   `--EXPR -> EXPR [135:47]
|       |       |       |       |       |       `--DOT -> . [135:47]
|       |       |       |       |       |           |--METHOD_CALL -> ( [135:45]
|       |       |       |       |       |           |   |--IDENT -> getXorData [135:35]
|       |       |       |       |       |           |   |--ELIST -> ELIST [135:46]
|       |       |       |       |       |           |   `--RPAREN -> ) [135:46]
|       |       |       |       |       |           `--IDENT -> length [135:48]
|       |       |       |       |       `--RPAREN -> ) [135:54]
|       |       |       |       |--SEMI -> ; [135:55]
|       |       |       |       `--RCURLY -> } [136:12]
|       |       |       `--RCURLY -> } [137:8]
|       |       `--RCURLY -> } [139:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [140:4]
|       |   |--MODIFIERS -> MODIFIERS [140:4]
|       |   |   `--LITERAL_PROTECTED -> protected [140:4]
|       |   |--TYPE -> TYPE [140:14]
|       |   |   |--IDENT -> TreeSet [140:14]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [140:21]
|       |   |       |--GENERIC_START -> < [140:21]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [140:22]
|       |   |       |   |--LITERAL_BYTE -> byte [140:22]
|       |   |       |   `--ARRAY_DECLARATOR -> [ [140:27]
|       |   |       |       `--RBRACK -> ] [140:28]
|       |   |       `--GENERIC_END -> > [140:29]
|       |   |--IDENT -> sortedPrefixes [140:31]
|       |   |--ASSIGN -> = [140:46]
|       |   |   `--EXPR -> EXPR [140:61]
|       |   |       `--METHOD_CALL -> ( [140:61]
|       |   |           |--IDENT -> createTreeSet [140:48]
|       |   |           |--ELIST -> ELIST [140:62]
|       |   |           `--RPAREN -> ) [140:62]
|       |   `--SEMI -> ; [140:63]
|       |--METHOD_DEF -> METHOD_DEF [142:4]
|       |   |--MODIFIERS -> MODIFIERS [142:4]
|       |   |--TYPE -> TYPE [142:4]
|       |   |   |--IDENT -> TreeSet [142:4]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [142:11]
|       |   |       |--GENERIC_START -> < [142:11]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [142:12]
|       |   |       |   |--LITERAL_BYTE -> byte [142:12]
|       |   |       |   `--ARRAY_DECLARATOR -> [ [142:16]
|       |   |       |       `--RBRACK -> ] [142:17]
|       |   |       `--GENERIC_END -> > [142:18]
|       |   |--IDENT -> createTreeSet [142:20]
|       |   |--LPAREN -> ( [142:33]
|       |   |--PARAMETERS -> PARAMETERS [142:34]
|       |   |--RPAREN -> ) [142:34]
|       |   `--SLIST -> { [142:36]
|       |       |--LITERAL_RETURN -> return [143:8]
|       |       |   |--EXPR -> EXPR [143:15]
|       |       |   |   `--LITERAL_NULL -> null [143:15]
|       |       |   `--SEMI -> ; [143:19]
|       |       `--RCURLY -> } [144:4]
|       |--METHOD_DEF -> METHOD_DEF [146:4]
|       |   |--MODIFIERS -> MODIFIERS [146:4]
|       |   |   `--LITERAL_PUBLIC -> public [146:4]
|       |   |--TYPE -> TYPE [146:11]
|       |   |   `--IDENT -> Object [146:11]
|       |   |--IDENT -> newInstance [146:18]
|       |   |--LPAREN -> ( [146:29]
|       |   |--PARAMETERS -> PARAMETERS [146:30]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [146:30]
|       |   |       |--MODIFIERS -> MODIFIERS [146:30]
|       |   |       |--TYPE -> TYPE [146:30]
|       |   |       |   |--IDENT -> Object [146:30]
|       |   |       |   `--ARRAY_DECLARATOR -> [ [146:36]
|       |   |       |       `--RBRACK -> ] [146:37]
|       |   |       `--IDENT -> objects [146:39]
|       |   |--RPAREN -> ) [146:46]
|       |   `--SLIST -> { [146:47]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [148:8]
|       |       |   |--MODIFIERS -> MODIFIERS [148:8]
|       |       |   |--TYPE -> TYPE [148:8]
|       |       |   |   `--IDENT -> InputAntlr4AstRegressionNewTypeTree [148:8]
|       |       |   |--IDENT -> tmpConstructor [148:44]
|       |       |   `--ASSIGN -> = [148:59]
|       |       |       `--EXPR -> EXPR [148:61]
|       |       |           `--LITERAL_NULL -> null [148:61]
|       |       |--SEMI -> ; [148:65]
|       |       |--LITERAL_RETURN -> return [149:8]
|       |       |   |--EXPR -> EXPR [149:41]
|       |       |   |   `--METHOD_CALL -> ( [149:41]
|       |       |   |       |--DOT -> . [149:29]
|       |       |   |       |   |--IDENT -> tmpConstructor [149:15]
|       |       |   |       |   `--IDENT -> newInstance [149:30]
|       |       |   |       |--ELIST -> ELIST [149:42]
|       |       |   |       |   `--EXPR -> EXPR [149:42]
|       |       |   |       |       `--TYPECAST -> ( [149:42]
|       |       |   |       |           |--TYPE -> TYPE [149:43]
|       |       |   |       |           |   |--IDENT -> Object [149:43]
|       |       |   |       |           |   `--ARRAY_DECLARATOR -> [ [149:49]
|       |       |   |       |           |       `--RBRACK -> ] [149:50]
|       |       |   |       |           |--RPAREN -> ) [149:51]
|       |       |   |       |           `--LITERAL_NULL -> null [149:52]
|       |       |   |       `--RPAREN -> ) [149:56]
|       |       |   `--SEMI -> ; [149:57]
|       |       `--RCURLY -> } [150:4]
|       |--METHOD_DEF -> METHOD_DEF [152:4]
|       |   |--MODIFIERS -> MODIFIERS [152:4]
|       |   |   `--LITERAL_PUBLIC -> public [152:4]
|       |   |--TYPE -> TYPE [152:11]
|       |   |   |--IDENT -> TypeVariable [152:11]
|       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [152:23]
|       |   |   |   |--GENERIC_START -> < [152:23]
|       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [152:24]
|       |   |   |   |   |--IDENT -> Class [152:24]
|       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [152:29]
|       |   |   |   |       |--GENERIC_START -> < [152:29]
|       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [152:30]
|       |   |   |   |       |   `--IDENT -> String [152:30]
|       |   |   |   |       `--GENERIC_END -> > [152:36]
|       |   |   |   `--GENERIC_END -> > [152:37]
|       |   |   `--ARRAY_DECLARATOR -> [ [152:38]
|       |   |       `--RBRACK -> ] [152:39]
|       |   |--IDENT -> getTypeParameters [152:41]
|       |   |--LPAREN -> ( [152:58]
|       |   |--PARAMETERS -> PARAMETERS [152:59]
|       |   |--RPAREN -> ) [152:59]
|       |   `--SLIST -> { [152:61]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [153:8]
|       |       |   |--MODIFIERS -> MODIFIERS [153:8]
|       |       |   |--TYPE -> TYPE [153:8]
|       |       |   |   `--IDENT -> ClassRepository [153:8]
|       |       |   |--IDENT -> info [153:24]
|       |       |   `--ASSIGN -> = [153:29]
|       |       |       `--EXPR -> EXPR [153:45]
|       |       |           `--METHOD_CALL -> ( [153:45]
|       |       |               |--IDENT -> getGenericInfo [153:31]
|       |       |               |--ELIST -> ELIST [153:46]
|       |       |               `--RPAREN -> ) [153:46]
|       |       |--SEMI -> ; [153:47]
|       |       |--LITERAL_IF -> if [154:8]
|       |       |   |--LPAREN -> ( [154:11]
|       |       |   |--EXPR -> EXPR [154:17]
|       |       |   |   `--NOT_EQUAL -> != [154:17]
|       |       |   |       |--IDENT -> info [154:12]
|       |       |   |       `--LITERAL_NULL -> null [154:20]
|       |       |   |--RPAREN -> ) [154:24]
|       |       |   |--LITERAL_RETURN -> return [155:12]
|       |       |   |   |--EXPR -> EXPR [155:19]
|       |       |   |   |   `--TYPECAST -> ( [155:19]
|       |       |   |   |       |--TYPE -> TYPE [155:20]
|       |       |   |   |       |   |--IDENT -> TypeVariable [155:20]
|       |       |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [155:32]
|       |       |   |   |       |   |   |--GENERIC_START -> < [155:32]
|       |       |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [155:33]
|       |       |   |   |       |   |   |   |--IDENT -> Class [155:33]
|       |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [155:38]
|       |       |   |   |       |   |   |       |--GENERIC_START -> < [155:38]
|       |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [155:39]
|       |       |   |   |       |   |   |       |   `--IDENT -> String [155:39]
|       |       |   |   |       |   |   |       `--GENERIC_END -> > [155:45]
|       |       |   |   |       |   |   `--GENERIC_END -> > [155:46]
|       |       |   |   |       |   `--ARRAY_DECLARATOR -> [ [155:47]
|       |       |   |   |       |       `--RBRACK -> ] [155:48]
|       |       |   |   |       |--RPAREN -> ) [155:49]
|       |       |   |   |       `--METHOD_CALL -> ( [155:72]
|       |       |   |   |           |--DOT -> . [155:54]
|       |       |   |   |           |   |--IDENT -> info [155:50]
|       |       |   |   |           |   `--IDENT -> getTypeParameters [155:55]
|       |       |   |   |           |--ELIST -> ELIST [155:73]
|       |       |   |   |           `--RPAREN -> ) [155:73]
|       |       |   |   `--SEMI -> ; [155:74]
|       |       |   `--LITERAL_ELSE -> else [156:8]
|       |       |       `--LITERAL_RETURN -> return [157:12]
|       |       |           |--EXPR -> EXPR [157:19]
|       |       |           |   `--TYPECAST -> ( [157:19]
|       |       |           |       |--TYPE -> TYPE [157:20]
|       |       |           |       |   |--IDENT -> TypeVariable [157:20]
|       |       |           |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:32]
|       |       |           |       |   |   |--GENERIC_START -> < [157:32]
|       |       |           |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:33]
|       |       |           |       |   |   |   |--IDENT -> Class [157:33]
|       |       |           |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:38]
|       |       |           |       |   |   |       |--GENERIC_START -> < [157:38]
|       |       |           |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:39]
|       |       |           |       |   |   |       |   `--IDENT -> String [157:39]
|       |       |           |       |   |   |       `--GENERIC_END -> > [157:45]
|       |       |           |       |   |   `--GENERIC_END -> > [157:46]
|       |       |           |       |   `--ARRAY_DECLARATOR -> [ [157:47]
|       |       |           |       |       `--RBRACK -> ] [157:48]
|       |       |           |       |--RPAREN -> ) [157:49]
|       |       |           |       `--LITERAL_NEW -> new [157:50]
|       |       |           |           |--IDENT -> TypeVariable [157:54]
|       |       |           |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:66]
|       |       |           |           |   |--GENERIC_START -> < [157:66]
|       |       |           |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:67]
|       |       |           |           |   |   `--WILDCARD_TYPE -> ? [157:67]
|       |       |           |           |   `--GENERIC_END -> > [157:68]
|       |       |           |           `--ARRAY_DECLARATOR -> [ [157:69]
|       |       |           |               |--EXPR -> EXPR [157:70]
|       |       |           |               |   `--NUM_INT -> 0 [157:70]
|       |       |           |               `--RBRACK -> ] [157:71]
|       |       |           `--SEMI -> ; [157:72]
|       |       `--RCURLY -> } [158:4]
|       |--CLASS_DEF -> CLASS_DEF [159:4]
|       |   |--MODIFIERS -> MODIFIERS [159:4]
|       |   |--LITERAL_CLASS -> class [159:4]
|       |   |--IDENT -> ClassRepository [159:10]
|       |   `--OBJBLOCK -> OBJBLOCK [159:26]
|       |       |--LCURLY -> { [159:26]
|       |       |--METHOD_DEF -> METHOD_DEF [161:8]
|       |       |   |--MODIFIERS -> MODIFIERS [161:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [161:8]
|       |       |   |--TYPE -> TYPE [161:15]
|       |       |   |   `--IDENT -> Object [161:15]
|       |       |   |--IDENT -> getTypeParameters [161:22]
|       |       |   |--LPAREN -> ( [161:39]
|       |       |   |--PARAMETERS -> PARAMETERS [161:40]
|       |       |   |--RPAREN -> ) [161:40]
|       |       |   `--SLIST -> { [161:42]
|       |       |       |--LITERAL_RETURN -> return [162:12]
|       |       |       |   |--EXPR -> EXPR [162:19]
|       |       |       |   |   `--LITERAL_NULL -> null [162:19]
|       |       |       |   `--SEMI -> ; [162:23]
|       |       |       `--RCURLY -> } [163:8]
|       |       `--RCURLY -> } [164:4]
|       |--CLASS_DEF -> CLASS_DEF [165:4]
|       |   |--MODIFIERS -> MODIFIERS [165:4]
|       |   |--LITERAL_CLASS -> class [165:4]
|       |   |--IDENT -> TypeVariable [165:10]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [165:22]
|       |   |   |--GENERIC_START -> < [165:22]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [165:23]
|       |   |   |   `--IDENT -> E [165:23]
|       |   |   `--GENERIC_END -> > [165:24]
|       |   `--OBJBLOCK -> OBJBLOCK [165:26]
|       |       |--LCURLY -> { [165:26]
|       |       `--RCURLY -> } [167:4]
|       |--METHOD_DEF -> METHOD_DEF [169:4]
|       |   |--MODIFIERS -> MODIFIERS [169:4]
|       |   |   `--LITERAL_PRIVATE -> private [169:4]
|       |   |--TYPE -> TYPE [169:12]
|       |   |   `--IDENT -> ClassRepository [169:12]
|       |   |--IDENT -> getGenericInfo [169:28]
|       |   |--LPAREN -> ( [169:42]
|       |   |--PARAMETERS -> PARAMETERS [169:43]
|       |   |--RPAREN -> ) [169:43]
|       |   `--SLIST -> { [169:45]
|       |       |--LITERAL_RETURN -> return [170:8]
|       |       |   |--EXPR -> EXPR [170:15]
|       |       |   |   `--LITERAL_NULL -> null [170:15]
|       |       |   `--SEMI -> ; [170:19]
|       |       `--RCURLY -> } [171:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [172:4]
|       |   |--MODIFIERS -> MODIFIERS [172:4]
|       |   |--TYPE -> TYPE [172:4]
|       |   |   |--IDENT -> String [172:4]
|       |   |   `--ARRAY_DECLARATOR -> [ [172:10]
|       |   |       `--RBRACK -> ] [172:11]
|       |   |--IDENT -> c [172:13]
|       |   `--SEMI -> ; [172:19]
|       |--COMMA -> , [172:14]
|       |--VARIABLE_DEF -> VARIABLE_DEF [172:4]
|       |   |--MODIFIERS -> MODIFIERS [172:4]
|       |   |--TYPE -> TYPE [172:4]
|       |   |   |--IDENT -> String [172:4]
|       |   |   |--ARRAY_DECLARATOR -> [ [172:10]
|       |   |   |   `--RBRACK -> ] [172:11]
|       |   |   `--ARRAY_DECLARATOR -> [ [172:17]
|       |   |       `--RBRACK -> ] [172:18]
|       |   `--IDENT -> d [172:16]
|       |--VARIABLE_DEF -> VARIABLE_DEF [173:4]
|       |   |--MODIFIERS -> MODIFIERS [173:4]
|       |   |--TYPE -> TYPE [173:4]
|       |   |   |--IDENT -> String [173:4]
|       |   |   `--ARRAY_DECLARATOR -> [ [173:11]
|       |   |       `--RBRACK -> ] [173:12]
|       |   |--IDENT -> e [173:14]
|       |   `--SEMI -> ; [173:21]
|       |--COMMA -> , [173:15]
|       |--VARIABLE_DEF -> VARIABLE_DEF [173:4]
|       |   |--MODIFIERS -> MODIFIERS [173:4]
|       |   |--TYPE -> TYPE [173:4]
|       |   |   |--IDENT -> String [173:4]
|       |   |   |--ARRAY_DECLARATOR -> [ [173:11]
|       |   |   |   `--RBRACK -> ] [173:12]
|       |   |   `--ARRAY_DECLARATOR -> [ [173:19]
|       |   |       `--RBRACK -> ] [173:20]
|       |   `--IDENT -> f [173:17]
|       |--ENUM_DEF -> ENUM_DEF [175:4]
|       |   |--MODIFIERS -> MODIFIERS [175:4]
|       |   |   `--LITERAL_PUBLIC -> public [175:4]
|       |   |--ENUM -> enum [175:11]
|       |   |--IDENT -> Stooge [175:16]
|       |   `--OBJBLOCK -> OBJBLOCK [175:23]
|       |       |--LCURLY -> { [175:23]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:8]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [176:8]
|       |       |   `--IDENT -> MOE [176:8]
|       |       |--COMMA -> , [176:11]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:13]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [176:13]
|       |       |   `--IDENT -> CURLY [176:13]
|       |       |--COMMA -> , [176:18]
|       |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:20]
|       |       |   |--ANNOTATIONS -> ANNOTATIONS [176:20]
|       |       |   `--IDENT -> LARRY [176:20]
|       |       |--COMMA -> , [176:25]
|       |       `--RCURLY -> } [177:4]
|       |--METHOD_DEF -> METHOD_DEF [178:4]
|       |   |--MODIFIERS -> MODIFIERS [178:4]
|       |   |   `--LITERAL_STATIC -> static [178:4]
|       |   |--TYPE -> TYPE [178:11]
|       |   |   `--LITERAL_VOID -> void [178:11]
|       |   |--IDENT -> checkArrayTypes1 [178:16]
|       |   |--LPAREN -> ( [178:32]
|       |   |--PARAMETERS -> PARAMETERS [178:33]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [178:33]
|       |   |   |   |--MODIFIERS -> MODIFIERS [178:33]
|       |   |   |   |--TYPE -> TYPE [178:33]
|       |   |   |   |   `--IDENT -> ArrayTypes [178:33]
|       |   |   |   `--IDENT -> at [178:44]
|       |   |   |--COMMA -> , [178:46]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [178:48]
|       |   |       |--MODIFIERS -> MODIFIERS [178:48]
|       |   |       |--TYPE -> TYPE [178:48]
|       |   |       |   `--IDENT -> AnnotatedElement [178:48]
|       |   |       `--IDENT -> e [178:65]
|       |   |--RPAREN -> ) [178:66]
|       |   `--SLIST -> { [178:68]
|       |       |--LITERAL_IF -> if [179:8]
|       |       |   |--LPAREN -> ( [179:11]
|       |       |   |--EXPR -> EXPR [179:12]
|       |       |   |   `--LNOT -> ! [179:12]
|       |       |   |       |--LPAREN -> ( [179:13]
|       |       |   |       |--LAND -> && [179:43]
|       |       |   |       |   |--EQUAL -> == [179:27]
|       |       |   |       |   |   |--INDEX_OP -> [ [179:22]
|       |       |   |       |   |   |   |--METHOD_CALL -> ( [179:20]
|       |       |   |       |   |   |   |   |--DOT -> . [179:16]
|       |       |   |       |   |   |   |   |   |--IDENT -> at [179:14]
|       |       |   |       |   |   |   |   |   `--IDENT -> cls [179:17]
|       |       |   |       |   |   |   |   |--ELIST -> ELIST [179:21]
|       |       |   |       |   |   |   |   `--RPAREN -> ) [179:21]
|       |       |   |       |   |   |   |--EXPR -> EXPR [179:23]
|       |       |   |       |   |   |   |   `--NUM_INT -> 0 [179:23]
|       |       |   |       |   |   |   `--RBRACK -> ] [179:24]
|       |       |   |       |   |   `--DOT -> . [179:33]
|       |       |   |       |   |       |--IDENT -> Map [179:30]
|       |       |   |       |   |       `--LITERAL_CLASS -> class [179:34]
|       |       |   |       |   `--EQUAL -> == [180:27]
|       |       |   |       |       |--INDEX_OP -> [ [180:20]
|       |       |   |       |       |   |--METHOD_CALL -> ( [180:18]
|       |       |   |       |       |   |   |--DOT -> . [180:16]
|       |       |   |       |       |   |   |   |--IDENT -> at [180:14]
|       |       |   |       |       |   |   |   `--IDENT -> e [180:17]
|       |       |   |       |       |   |   |--ELIST -> ELIST [180:19]
|       |       |   |       |       |   |   `--RPAREN -> ) [180:19]
|       |       |   |       |       |   |--EXPR -> EXPR [180:21]
|       |       |   |       |       |   |   `--NUM_INT -> 0 [180:21]
|       |       |   |       |       |   `--RBRACK -> ] [180:22]
|       |       |   |       |       `--DOT -> . [180:36]
|       |       |   |       |           |--IDENT -> Stooge [180:30]
|       |       |   |       |           `--IDENT -> MOE [180:37]
|       |       |   |       `--RPAREN -> ) [180:42]
|       |       |   |--RPAREN -> ) [180:43]
|       |       |   `--SLIST -> { [180:45]
|       |       |       `--RCURLY -> } [182:8]
|       |       `--RCURLY -> } [183:4]
|       |--CLASS_DEF -> CLASS_DEF [185:4]
|       |   |--MODIFIERS -> MODIFIERS [185:4]
|       |   |   `--LITERAL_STATIC -> static [185:4]
|       |   |--LITERAL_CLASS -> class [185:11]
|       |   |--IDENT -> ArrayTypes [185:17]
|       |   `--OBJBLOCK -> OBJBLOCK [185:28]
|       |       |--LCURLY -> { [185:28]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [186:8]
|       |       |   |--MODIFIERS -> MODIFIERS [186:8]
|       |       |   |--TYPE -> TYPE [186:8]
|       |       |   |   |--IDENT -> Object [186:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [186:14]
|       |       |   |       `--RBRACK -> ] [186:15]
|       |       |   |--IDENT -> cls [186:17]
|       |       |   `--SEMI -> ; [186:20]
|       |       |--METHOD_DEF -> METHOD_DEF [188:8]
|       |       |   |--MODIFIERS -> MODIFIERS [188:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [188:8]
|       |       |   |--TYPE -> TYPE [188:15]
|       |       |   |   |--IDENT -> Stooge [188:15]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [188:21]
|       |       |   |       `--RBRACK -> ] [188:22]
|       |       |   |--IDENT -> e [188:24]
|       |       |   |--LPAREN -> ( [188:25]
|       |       |   |--PARAMETERS -> PARAMETERS [188:26]
|       |       |   |--RPAREN -> ) [188:26]
|       |       |   `--SLIST -> { [188:28]
|       |       |       |--LITERAL_RETURN -> return [189:12]
|       |       |       |   |--EXPR -> EXPR [189:19]
|       |       |       |   |   `--LITERAL_NULL -> null [189:19]
|       |       |       |   `--SEMI -> ; [189:23]
|       |       |       `--RCURLY -> } [190:8]
|       |       |--METHOD_DEF -> METHOD_DEF [194:8]
|       |       |   |--MODIFIERS -> MODIFIERS [194:8]
|       |       |   |--TYPE -> TYPE [194:8]
|       |       |   |   |--IDENT -> Object [194:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [194:14]
|       |       |   |       `--RBRACK -> ] [194:15]
|       |       |   |--IDENT -> cls [194:17]
|       |       |   |--LPAREN -> ( [194:20]
|       |       |   |--PARAMETERS -> PARAMETERS [194:21]
|       |       |   |--RPAREN -> ) [194:21]
|       |       |   `--SLIST -> { [194:23]
|       |       |       |--LITERAL_RETURN -> return [195:12]
|       |       |       |   |--EXPR -> EXPR [195:19]
|       |       |       |   |   `--IDENT -> cls [195:19]
|       |       |       |   `--SEMI -> ; [195:22]
|       |       |       `--RCURLY -> } [196:8]
|       |       |--METHOD_DEF -> METHOD_DEF [198:8]
|       |       |   |--MODIFIERS -> MODIFIERS [198:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [198:8]
|       |       |   |--TYPE -> TYPE [198:15]
|       |       |   |   |--LITERAL_INT -> int [198:15]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [198:18]
|       |       |   |       `--RBRACK -> ] [198:19]
|       |       |   |--IDENT -> a [198:21]
|       |       |   |--LPAREN -> ( [198:22]
|       |       |   |--PARAMETERS -> PARAMETERS [198:23]
|       |       |   |--RPAREN -> ) [198:23]
|       |       |   `--SLIST -> { [198:25]
|       |       |       |--LITERAL_RETURN -> return [199:12]
|       |       |       |   |--EXPR -> EXPR [199:19]
|       |       |       |   |   `--LITERAL_NULL -> null [199:19]
|       |       |       |   `--SEMI -> ; [199:23]
|       |       |       `--RCURLY -> } [200:8]
|       |       `--RCURLY -> } [201:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [202:4]
|       |   |--MODIFIERS -> MODIFIERS [202:4]
|       |   |--TYPE -> TYPE [202:4]
|       |   |   |--LITERAL_INT -> int [202:4]
|       |   |   |--ARRAY_DECLARATOR -> [ [202:7]
|       |   |   |   `--RBRACK -> ] [202:8]
|       |   |   |--ARRAY_DECLARATOR -> [ [202:9]
|       |   |   |   `--RBRACK -> ] [203:4]
|       |   |   |--ARRAY_DECLARATOR -> [ [205:5]
|       |   |   |   `--RBRACK -> ] [205:6]
|       |   |   `--ARRAY_DECLARATOR -> [ [206:12]
|       |   |       `--RBRACK -> ] [206:13]
|       |   |--IDENT -> w [204:5]
|       |   `--SEMI -> ; [206:15]
|       |--VARIABLE_DEF -> VARIABLE_DEF [207:4]
|       |   |--MODIFIERS -> MODIFIERS [207:4]
|       |   |--TYPE -> TYPE [207:4]
|       |   |   |--LITERAL_INT -> int [207:4]
|       |   |   |--ARRAY_DECLARATOR -> [ [207:7]
|       |   |   |   `--RBRACK -> ] [207:8]
|       |   |   |--ARRAY_DECLARATOR -> [ [207:9]
|       |   |   |   `--RBRACK -> ] [208:5]
|       |   |   |--ARRAY_DECLARATOR -> [ [210:4]
|       |   |   |   `--RBRACK -> ] [210:5]
|       |   |   `--ARRAY_DECLARATOR -> [ [211:12]
|       |   |       `--RBRACK -> ] [211:13]
|       |   |--IDENT -> z [209:5]
|       |   `--SEMI -> ; [211:15]
|       |--CLASS_DEF -> CLASS_DEF [213:4]
|       |   |--MODIFIERS -> MODIFIERS [213:4]
|       |   |   `--LITERAL_STATIC -> static [213:4]
|       |   |--LITERAL_CLASS -> class [213:11]
|       |   |--IDENT -> P [213:17]
|       |   `--OBJBLOCK -> OBJBLOCK [213:19]
|       |       |--LCURLY -> { [213:19]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [214:8]
|       |       |   |--MODIFIERS -> MODIFIERS [214:8]
|       |       |   |   `--LITERAL_PRIVATE -> private [214:8]
|       |       |   |--TYPE -> TYPE [214:16]
|       |       |   |   `--LITERAL_INT -> int [214:16]
|       |       |   |--IDENT -> x [214:20]
|       |       |   `--SEMI -> ; [214:21]
|       |       |--METHOD_DEF -> METHOD_DEF [216:8]
|       |       |   |--MODIFIERS -> MODIFIERS [216:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [216:8]
|       |       |   |--TYPE -> TYPE [216:15]
|       |       |   |   `--LITERAL_VOID -> void [216:15]
|       |       |   |--IDENT -> set3 [216:20]
|       |       |   |--LPAREN -> ( [216:24]
|       |       |   |--PARAMETERS -> PARAMETERS [216:25]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [216:25]
|       |       |   |       |--MODIFIERS -> MODIFIERS [216:25]
|       |       |   |       |--TYPE -> TYPE [216:25]
|       |       |   |       |   `--IDENT -> P [216:25]
|       |       |   |       `--IDENT -> p [216:27]
|       |       |   |--RPAREN -> ) [216:28]
|       |       |   `--SLIST -> { [216:30]
|       |       |       |--LITERAL_SYNCHRONIZED -> synchronized [217:14]
|       |       |       |   |--LPAREN -> ( [217:27]
|       |       |       |   |--EXPR -> EXPR [217:28]
|       |       |       |   |   `--LITERAL_THIS -> this [217:28]
|       |       |       |   |--RPAREN -> ) [217:32]
|       |       |       |   `--SLIST -> { [217:34]
|       |       |       |       |--EXPR -> EXPR [218:22]
|       |       |       |       |   `--ASSIGN -> = [218:22]
|       |       |       |       |       |--DOT -> . [218:19]
|       |       |       |       |       |   |--IDENT -> p [218:18]
|       |       |       |       |       |   `--IDENT -> x [218:20]
|       |       |       |       |       `--INDEX_OP -> [ [218:29]
|       |       |       |       |           |--METHOD_CALL -> ( [218:27]
|       |       |       |       |           |   |--IDENT -> get [218:24]
|       |       |       |       |           |   |--ELIST -> ELIST [218:28]
|       |       |       |       |           |   `--RPAREN -> ) [218:28]
|       |       |       |       |           |--EXPR -> EXPR [218:30]
|       |       |       |       |           |   `--NUM_INT -> 0 [218:30]
|       |       |       |       |           `--RBRACK -> ] [218:31]
|       |       |       |       |--SEMI -> ; [218:32]
|       |       |       |       `--RCURLY -> } [219:14]
|       |       |       `--RCURLY -> } [220:10]
|       |       |--METHOD_DEF -> METHOD_DEF [222:8]
|       |       |   |--MODIFIERS -> MODIFIERS [222:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [222:8]
|       |       |   |--TYPE -> TYPE [222:15]
|       |       |   |   `--LITERAL_VOID -> void [222:15]
|       |       |   |--IDENT -> set4 [222:20]
|       |       |   |--LPAREN -> ( [222:24]
|       |       |   |--PARAMETERS -> PARAMETERS [222:25]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [222:25]
|       |       |   |       |--MODIFIERS -> MODIFIERS [222:25]
|       |       |   |       |--TYPE -> TYPE [222:25]
|       |       |   |       |   `--IDENT -> P [222:25]
|       |       |   |       `--IDENT -> p [222:27]
|       |       |   |--RPAREN -> ) [222:28]
|       |       |   `--SLIST -> { [222:30]
|       |       |       |--LITERAL_SYNCHRONIZED -> synchronized [223:14]
|       |       |       |   |--LPAREN -> ( [223:26]
|       |       |       |   |--EXPR -> EXPR [223:27]
|       |       |       |   |   `--LITERAL_THIS -> this [223:27]
|       |       |       |   |--RPAREN -> ) [223:31]
|       |       |       |   `--SLIST -> { [223:33]
|       |       |       |       |--EXPR -> EXPR [224:22]
|       |       |       |       |   `--ASSIGN -> = [224:22]
|       |       |       |       |       |--DOT -> . [224:19]
|       |       |       |       |       |   |--IDENT -> p [224:18]
|       |       |       |       |       |   `--IDENT -> x [224:20]
|       |       |       |       |       `--INDEX_OP -> [ [224:29]
|       |       |       |       |           |--METHOD_CALL -> ( [224:27]
|       |       |       |       |           |   |--IDENT -> get [224:24]
|       |       |       |       |           |   |--ELIST -> ELIST [224:28]
|       |       |       |       |           |   `--RPAREN -> ) [224:28]
|       |       |       |       |           |--EXPR -> EXPR [224:30]
|       |       |       |       |           |   `--NUM_INT -> 0 [224:30]
|       |       |       |       |           `--RBRACK -> ] [224:31]
|       |       |       |       |--SEMI -> ; [224:32]
|       |       |       |       `--RCURLY -> } [225:14]
|       |       |       `--RCURLY -> } [226:10]
|       |       |--METHOD_DEF -> METHOD_DEF [228:8]
|       |       |   |--MODIFIERS -> MODIFIERS [228:8]
|       |       |   |   `--LITERAL_PRIVATE -> private [228:8]
|       |       |   |--TYPE -> TYPE [228:16]
|       |       |   |   |--LITERAL_INT -> int [228:16]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [228:19]
|       |       |   |       `--RBRACK -> ] [228:20]
|       |       |   |--IDENT -> get [228:22]
|       |       |   |--LPAREN -> ( [228:25]
|       |       |   |--PARAMETERS -> PARAMETERS [228:26]
|       |       |   |--RPAREN -> ) [228:26]
|       |       |   `--SLIST -> { [228:28]
|       |       |       |--LITERAL_RETURN -> return [229:12]
|       |       |       |   |--EXPR -> EXPR [229:19]
|       |       |       |   |   `--LITERAL_NULL -> null [229:19]
|       |       |       |   `--SEMI -> ; [229:23]
|       |       |       `--RCURLY -> } [230:8]
|       |       `--RCURLY -> } [231:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [233:4]
|       |   |--MODIFIERS -> MODIFIERS [233:4]
|       |   |   |--LITERAL_PRIVATE -> private [233:4]
|       |   |   `--ANNOTATION -> ANNOTATION [233:12]
|       |   |       |--AT -> @ [233:12]
|       |   |       `--IDENT -> Nullable [233:13]
|       |   |--TYPE -> TYPE [233:22]
|       |   |   |--LITERAL_INT -> int [233:22]
|       |   |   |--ANNOTATIONS -> ANNOTATIONS [233:33]
|       |   |   |   `--ANNOTATION -> ANNOTATION [233:33]
|       |   |   |       |--AT -> @ [233:33]
|       |   |   |       `--IDENT -> Nullable [233:34]
|       |   |   |--ARRAY_DECLARATOR -> [ [233:43]
|       |   |   |   `--RBRACK -> ] [233:44]
|       |   |   |--ANNOTATIONS -> ANNOTATIONS [233:46]
|       |   |   |   `--ANNOTATION -> ANNOTATION [233:46]
|       |   |   |       |--AT -> @ [233:46]
|       |   |   |       `--IDENT -> Nullable [233:47]
|       |   |   `--ARRAY_DECLARATOR -> [ [233:56]
|       |   |       `--RBRACK -> ] [233:57]
|       |   |--IDENT -> array2 [233:26]
|       |   `--SEMI -> ; [233:58]
|       `--RCURLY -> } [234:0]
|--ANNOTATION_DEF -> ANNOTATION_DEF [237:0]
|   |--MODIFIERS -> MODIFIERS [237:0]
|   |   `--ANNOTATION -> ANNOTATION [237:0]
|   |       |--AT -> @ [237:0]
|   |       |--IDENT -> Target [237:1]
|   |       |--LPAREN -> ( [237:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [237:8]
|   |       |   |--EXPR -> EXPR [237:20]
|   |       |   |   `--DOT -> . [237:20]
|   |       |   |       |--IDENT -> ElementType [237:9]
|   |       |   |       `--IDENT -> TYPE_USE [237:21]
|   |       |   |--COMMA -> , [237:29]
|   |       |   |--EXPR -> EXPR [237:42]
|   |       |   |   `--DOT -> . [237:42]
|   |       |   |       |--IDENT -> ElementType [237:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [237:43]
|   |       |   `--RCURLY -> } [237:57]
|   |       `--RPAREN -> ) [237:58]
|   |--AT -> @ [238:0]
|   |--LITERAL_INTERFACE -> interface [238:1]
|   |--IDENT -> Nullable [238:11]
|   `--OBJBLOCK -> OBJBLOCK [238:19]
|       |--LCURLY -> { [238:19]
|       `--RCURLY -> } [238:20]
|--ANNOTATION_DEF -> ANNOTATION_DEF [240:0]
|   |--MODIFIERS -> MODIFIERS [240:0]
|   |   `--ANNOTATION -> ANNOTATION [240:0]
|   |       |--AT -> @ [240:0]
|   |       |--IDENT -> Target [240:1]
|   |       |--LPAREN -> ( [240:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [240:8]
|   |       |   |--EXPR -> EXPR [240:20]
|   |       |   |   `--DOT -> . [240:20]
|   |       |   |       |--IDENT -> ElementType [240:9]
|   |       |   |       `--IDENT -> TYPE_USE [240:21]
|   |       |   |--COMMA -> , [240:29]
|   |       |   |--EXPR -> EXPR [240:42]
|   |       |   |   `--DOT -> . [240:42]
|   |       |   |       |--IDENT -> ElementType [240:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [240:43]
|   |       |   `--RCURLY -> } [240:57]
|   |       `--RPAREN -> ) [240:58]
|   |--AT -> @ [241:0]
|   |--LITERAL_INTERFACE -> interface [241:1]
|   |--IDENT -> I [241:11]
|   `--OBJBLOCK -> OBJBLOCK [241:13]
|       |--LCURLY -> { [241:13]
|       `--RCURLY -> } [241:14]
|--ANNOTATION_DEF -> ANNOTATION_DEF [243:0]
|   |--MODIFIERS -> MODIFIERS [243:0]
|   |   `--ANNOTATION -> ANNOTATION [243:0]
|   |       |--AT -> @ [243:0]
|   |       |--IDENT -> Target [243:1]
|   |       |--LPAREN -> ( [243:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [243:8]
|   |       |   |--EXPR -> EXPR [243:20]
|   |       |   |   `--DOT -> . [243:20]
|   |       |   |       |--IDENT -> ElementType [243:9]
|   |       |   |       `--IDENT -> TYPE_USE [243:21]
|   |       |   |--COMMA -> , [243:29]
|   |       |   |--EXPR -> EXPR [243:42]
|   |       |   |   `--DOT -> . [243:42]
|   |       |   |       |--IDENT -> ElementType [243:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [243:43]
|   |       |   `--RCURLY -> } [243:57]
|   |       `--RPAREN -> ) [243:58]
|   |--AT -> @ [244:0]
|   |--LITERAL_INTERFACE -> interface [244:1]
|   |--IDENT -> J [244:11]
|   `--OBJBLOCK -> OBJBLOCK [244:13]
|       |--LCURLY -> { [244:13]
|       `--RCURLY -> } [244:14]
|--ANNOTATION_DEF -> ANNOTATION_DEF [246:0]
|   |--MODIFIERS -> MODIFIERS [246:0]
|   |   `--ANNOTATION -> ANNOTATION [246:0]
|   |       |--AT -> @ [246:0]
|   |       |--IDENT -> Target [246:1]
|   |       |--LPAREN -> ( [246:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [246:8]
|   |       |   |--EXPR -> EXPR [246:20]
|   |       |   |   `--DOT -> . [246:20]
|   |       |   |       |--IDENT -> ElementType [246:9]
|   |       |   |       `--IDENT -> TYPE_USE [246:21]
|   |       |   |--COMMA -> , [246:29]
|   |       |   |--EXPR -> EXPR [246:42]
|   |       |   |   `--DOT -> . [246:42]
|   |       |   |       |--IDENT -> ElementType [246:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [246:43]
|   |       |   `--RCURLY -> } [246:57]
|   |       `--RPAREN -> ) [246:58]
|   |--AT -> @ [247:0]
|   |--LITERAL_INTERFACE -> interface [247:1]
|   |--IDENT -> K [247:11]
|   `--OBJBLOCK -> OBJBLOCK [247:13]
|       |--LCURLY -> { [247:13]
|       `--RCURLY -> } [247:14]
`--ANNOTATION_DEF -> ANNOTATION_DEF [249:0]
    |--MODIFIERS -> MODIFIERS [249:0]
    |   `--ANNOTATION -> ANNOTATION [249:0]
    |       |--AT -> @ [249:0]
    |       |--IDENT -> Target [249:1]
    |       |--LPAREN -> ( [249:7]
    |       |--ANNOTATION_ARRAY_INIT -> { [249:8]
    |       |   |--EXPR -> EXPR [249:20]
    |       |   |   `--DOT -> . [249:20]
    |       |   |       |--IDENT -> ElementType [249:9]
    |       |   |       `--IDENT -> TYPE_USE [249:21]
    |       |   |--COMMA -> , [249:29]
    |       |   |--EXPR -> EXPR [249:42]
    |       |   |   `--DOT -> . [249:42]
    |       |   |       |--IDENT -> ElementType [249:31]
    |       |   |       `--IDENT -> TYPE_PARAMETER [249:43]
    |       |   `--RCURLY -> } [249:57]
    |       `--RPAREN -> ) [249:58]
    |--AT -> @ [250:0]
    |--LITERAL_INTERFACE -> interface [250:1]
    |--IDENT -> L [250:11]
    `--OBJBLOCK -> OBJBLOCK [250:13]
        |--LCURLY -> { [250:13]
        `--RCURLY -> } [250:14]
