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