COMPILATION_UNIT -> COMPILATION_UNIT [1:0]
|--PACKAGE_DEF -> package [1:0]
|   |--ANNOTATIONS -> ANNOTATIONS [1:47]
|   |--DOT -> . [1:47]
|   |   |--DOT -> . [1:39]
|   |   |   |--DOT -> . [1:28]
|   |   |   |   |--DOT -> . [1:22]
|   |   |   |   |   |--DOT -> . [1:11]
|   |   |   |   |   |   |--IDENT -> com [1:8]
|   |   |   |   |   |   `--IDENT -> puppycrawl [1:12]
|   |   |   |   |   `--IDENT -> tools [1:23]
|   |   |   |   `--IDENT -> checkstyle [1:29]
|   |   |   `--IDENT -> grammar [1:40]
|   |   `--IDENT -> antlr4 [1:48]
|   `--SEMI -> ; [1:54]
|--IMPORT -> import [3:0]
|   |--DOT -> . [3:14]
|   |   |--DOT -> . [3:11]
|   |   |   |--IDENT -> java [3:7]
|   |   |   `--IDENT -> io [3:12]
|   |   `--IDENT -> BufferedReader [3:15]
|   `--SEMI -> ; [3:29]
|--IMPORT -> import [4:0]
|   |--DOT -> . [4:14]
|   |   |--DOT -> . [4:11]
|   |   |   |--IDENT -> java [4:7]
|   |   |   `--IDENT -> io [4:12]
|   |   `--IDENT -> IOException [4:15]
|   `--SEMI -> ; [4:26]
|--IMPORT -> import [5:0]
|   |--DOT -> . [5:14]
|   |   |--DOT -> . [5:11]
|   |   |   |--IDENT -> java [5:7]
|   |   |   `--IDENT -> io [5:12]
|   |   `--IDENT -> InputStreamReader [5:15]
|   `--SEMI -> ; [5:32]
|--IMPORT -> import [6:0]
|   |--DOT -> . [6:16]
|   |   |--DOT -> . [6:11]
|   |   |   |--IDENT -> java [6:7]
|   |   |   `--IDENT -> util [6:12]
|   |   `--IDENT -> ArrayList [6:17]
|   `--SEMI -> ; [6:26]
|--IMPORT -> import [7:0]
|   |--DOT -> . [7:16]
|   |   |--DOT -> . [7:11]
|   |   |   |--IDENT -> java [7:7]
|   |   |   `--IDENT -> util [7:12]
|   |   `--IDENT -> HashMap [7:17]
|   `--SEMI -> ; [7:24]
|--IMPORT -> import [8:0]
|   |--DOT -> . [8:16]
|   |   |--DOT -> . [8:11]
|   |   |   |--IDENT -> java [8:7]
|   |   |   `--IDENT -> util [8:12]
|   |   `--IDENT -> List [8:17]
|   `--SEMI -> ; [8:21]
|--IMPORT -> import [9:0]
|   |--DOT -> . [9:16]
|   |   |--DOT -> . [9:11]
|   |   |   |--IDENT -> java [9:7]
|   |   |   `--IDENT -> util [9:12]
|   |   `--IDENT -> Map [9:17]
|   `--SEMI -> ; [9:20]
`--CLASS_DEF -> CLASS_DEF [11:0]
    |--MODIFIERS -> MODIFIERS [11:0]
    |   `--LITERAL_PUBLIC -> public [11:0]
    |--LITERAL_CLASS -> class [11:7]
    |--IDENT -> InputRegressionJavaClass1 [11:13]
    `--OBJBLOCK -> OBJBLOCK [11:39]
        |--LCURLY -> { [11:39]
        |--VARIABLE_DEF -> VARIABLE_DEF [23:4]
        |   |--MODIFIERS -> MODIFIERS [23:4]
        |   |   `--LITERAL_PUBLIC -> public [23:4]
        |   |--TYPE -> TYPE [23:11]
        |   |   `--LITERAL_INT -> int [23:11]
        |   |--IDENT -> f1 [23:15]
        |   `--SEMI -> ; [23:17]
        |--VARIABLE_DEF -> VARIABLE_DEF [24:4]
        |   |--MODIFIERS -> MODIFIERS [24:4]
        |   |   `--LITERAL_PRIVATE -> private [24:4]
        |   |--TYPE -> TYPE [24:12]
        |   |   `--LITERAL_INT -> int [24:12]
        |   |--IDENT -> f2 [24:16]
        |   `--SEMI -> ; [24:18]
        |--VARIABLE_DEF -> VARIABLE_DEF [25:4]
        |   |--MODIFIERS -> MODIFIERS [25:4]
        |   |   `--LITERAL_PROTECTED -> protected [25:4]
        |   |--TYPE -> TYPE [25:14]
        |   |   `--LITERAL_INT -> int [25:14]
        |   |--IDENT -> f3 [25:18]
        |   `--SEMI -> ; [25:20]
        |--VARIABLE_DEF -> VARIABLE_DEF [26:4]
        |   |--MODIFIERS -> MODIFIERS [26:4]
        |   |--TYPE -> TYPE [26:4]
        |   |   `--LITERAL_INT -> int [26:4]
        |   |--IDENT -> f4 [26:8]
        |   `--SEMI -> ; [26:10]
        |--VARIABLE_DEF -> VARIABLE_DEF [27:4]
        |   |--MODIFIERS -> MODIFIERS [27:4]
        |   |   `--LITERAL_STATIC -> static [27:4]
        |   |--TYPE -> TYPE [27:11]
        |   |   `--LITERAL_INT -> int [27:11]
        |   |--IDENT -> f5 [27:15]
        |   `--SEMI -> ; [27:17]
        |--VARIABLE_DEF -> VARIABLE_DEF [28:4]
        |   |--MODIFIERS -> MODIFIERS [28:4]
        |   |   `--FINAL -> final [28:4]
        |   |--TYPE -> TYPE [28:10]
        |   |   `--LITERAL_INT -> int [28:10]
        |   |--IDENT -> f6 [28:14]
        |   `--SEMI -> ; [28:16]
        |--VARIABLE_DEF -> VARIABLE_DEF [29:4]
        |   |--MODIFIERS -> MODIFIERS [29:4]
        |   |   `--LITERAL_VOLATILE -> volatile [29:4]
        |   |--TYPE -> TYPE [29:13]
        |   |   `--LITERAL_INT -> int [29:13]
        |   |--IDENT -> f7 [29:17]
        |   `--SEMI -> ; [29:19]
        |--VARIABLE_DEF -> VARIABLE_DEF [30:4]
        |   |--MODIFIERS -> MODIFIERS [30:4]
        |   |   `--LITERAL_TRANSIENT -> transient [30:4]
        |   |--TYPE -> TYPE [30:14]
        |   |   `--LITERAL_INT -> int [30:14]
        |   |--IDENT -> f8 [30:18]
        |   `--SEMI -> ; [30:20]
        |--VARIABLE_DEF -> VARIABLE_DEF [31:4]
        |   |--MODIFIERS -> MODIFIERS [31:4]
        |   |--TYPE -> TYPE [31:4]
        |   |   `--IDENT -> Object [31:4]
        |   |--IDENT -> f9 [31:11]
        |   `--SEMI -> ; [31:13]
        |--STATIC_INIT -> STATIC_INIT [34:4]
        |   `--SLIST -> { [34:11]
        |       `--RCURLY -> } [34:12]
        |--CTOR_DEF -> CTOR_DEF [35:4]
        |   |--MODIFIERS -> MODIFIERS [35:4]
        |   |   `--LITERAL_PUBLIC -> public [35:4]
        |   |--IDENT -> InputRegressionJavaClass1 [35:11]
        |   |--LPAREN -> ( [35:36]
        |   |--PARAMETERS -> PARAMETERS [35:37]
        |   |--RPAREN -> ) [35:37]
        |   `--SLIST -> { [35:39]
        |       |--EXPR -> EXPR [35:43]
        |       |   `--ASSIGN -> = [35:43]
        |       |       |--IDENT -> f6 [35:40]
        |       |       `--NUM_INT -> 0 [35:45]
        |       |--SEMI -> ; [35:46]
        |       `--RCURLY -> } [35:47]
        |--CTOR_DEF -> CTOR_DEF [36:4]
        |   |--MODIFIERS -> MODIFIERS [36:4]
        |   |   `--LITERAL_PUBLIC -> public [36:4]
        |   |--IDENT -> InputRegressionJavaClass1 [36:11]
        |   |--LPAREN -> ( [36:36]
        |   |--PARAMETERS -> PARAMETERS [36:37]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:37]
        |   |       |--MODIFIERS -> MODIFIERS [36:37]
        |   |       |--TYPE -> TYPE [36:37]
        |   |       |   `--LITERAL_INT -> int [36:37]
        |   |       `--IDENT -> i [36:41]
        |   |--RPAREN -> ) [36:42]
        |   `--SLIST -> { [36:44]
        |       |--EXPR -> EXPR [36:53]
        |       |   `--ASSIGN -> = [36:53]
        |       |       |--DOT -> . [36:49]
        |       |       |   |--LITERAL_THIS -> this [36:45]
        |       |       |   `--IDENT -> f6 [36:50]
        |       |       `--IDENT -> i [36:55]
        |       |--SEMI -> ; [36:56]
        |       `--RCURLY -> } [36:57]
        |--CTOR_DEF -> CTOR_DEF [37:4]
        |   |--MODIFIERS -> MODIFIERS [37:4]
        |   |   `--LITERAL_PUBLIC -> public [37:4]
        |   |--IDENT -> InputRegressionJavaClass1 [37:11]
        |   |--LPAREN -> ( [37:36]
        |   |--PARAMETERS -> PARAMETERS [37:37]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [37:37]
        |   |       |--MODIFIERS -> MODIFIERS [37:37]
        |   |       |--TYPE -> TYPE [37:37]
        |   |       |   `--LITERAL_FLOAT -> float [37:37]
        |   |       `--IDENT -> f [37:43]
        |   |--RPAREN -> ) [37:44]
        |   `--SLIST -> { [37:46]
        |       |--CTOR_CALL -> this [37:47]
        |       |   |--LPAREN -> ( [37:51]
        |       |   |--ELIST -> ELIST [37:52]
        |       |   |   `--EXPR -> EXPR [37:52]
        |       |   |       `--TYPECAST -> ( [37:52]
        |       |   |           |--TYPE -> TYPE [37:53]
        |       |   |           |   `--LITERAL_INT -> int [37:53]
        |       |   |           |--RPAREN -> ) [37:56]
        |       |   |           `--IDENT -> f [37:57]
        |       |   |--RPAREN -> ) [37:58]
        |       |   `--SEMI -> ; [37:59]
        |       `--RCURLY -> } [37:60]
        |--CTOR_DEF -> CTOR_DEF [38:4]
        |   |--MODIFIERS -> MODIFIERS [38:4]
        |   |--IDENT -> InputRegressionJavaClass1 [38:4]
        |   |--LPAREN -> ( [38:29]
        |   |--PARAMETERS -> PARAMETERS [38:30]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:30]
        |   |       |--MODIFIERS -> MODIFIERS [38:30]
        |   |       |--TYPE -> TYPE [38:30]
        |   |       |   `--LITERAL_DOUBLE -> double [38:30]
        |   |       `--IDENT -> a [38:37]
        |   |--RPAREN -> ) [38:38]
        |   |--LITERAL_THROWS -> throws [38:40]
        |   |   `--IDENT -> Exception [38:47]
        |   `--SLIST -> { [38:57]
        |       |--EXPR -> EXPR [38:61]
        |       |   `--ASSIGN -> = [38:61]
        |       |       |--IDENT -> f6 [38:58]
        |       |       `--NUM_INT -> 0 [38:63]
        |       |--SEMI -> ; [38:64]
        |       `--RCURLY -> } [38:65]
        |--METHOD_DEF -> METHOD_DEF [42:4]
        |   |--MODIFIERS -> MODIFIERS [42:4]
        |   |   `--LITERAL_NATIVE -> native [42:4]
        |   |--TYPE -> TYPE [42:11]
        |   |   `--LITERAL_VOID -> void [42:11]
        |   |--IDENT -> m1 [42:16]
        |   |--LPAREN -> ( [42:18]
        |   |--PARAMETERS -> PARAMETERS [42:19]
        |   |--RPAREN -> ) [42:19]
        |   `--SEMI -> ; [42:20]
        |--METHOD_DEF -> METHOD_DEF [43:4]
        |   |--MODIFIERS -> MODIFIERS [43:4]
        |   |--TYPE -> TYPE [43:4]
        |   |   `--LITERAL_VOID -> void [43:4]
        |   |--IDENT -> m2 [43:9]
        |   |--LPAREN -> ( [43:11]
        |   |--PARAMETERS -> PARAMETERS [43:12]
        |   |--RPAREN -> ) [43:12]
        |   `--SLIST -> { [43:14]
        |       `--RCURLY -> } [43:15]
        |--METHOD_DEF -> METHOD_DEF [44:4]
        |   |--MODIFIERS -> MODIFIERS [44:4]
        |   |   `--LITERAL_SYNCHRONIZED -> synchronized [44:4]
        |   |--TYPE -> TYPE [44:17]
        |   |   `--LITERAL_VOID -> void [44:17]
        |   |--IDENT -> m4 [44:22]
        |   |--LPAREN -> ( [44:24]
        |   |--PARAMETERS -> PARAMETERS [44:25]
        |   |--RPAREN -> ) [44:25]
        |   `--SLIST -> { [44:27]
        |       `--RCURLY -> } [44:28]
        |--METHOD_DEF -> METHOD_DEF [45:4]
        |   |--MODIFIERS -> MODIFIERS [45:4]
        |   |   `--STRICTFP -> strictfp [45:4]
        |   |--TYPE -> TYPE [45:13]
        |   |   `--LITERAL_VOID -> void [45:13]
        |   |--IDENT -> m5 [45:18]
        |   |--LPAREN -> ( [45:20]
        |   |--PARAMETERS -> PARAMETERS [45:21]
        |   |--RPAREN -> ) [45:21]
        |   `--SLIST -> { [45:23]
        |       `--RCURLY -> } [45:24]
        |--METHOD_DEF -> METHOD_DEF [48:4]
        |   |--MODIFIERS -> MODIFIERS [48:4]
        |   |   `--LITERAL_PUBLIC -> public [48:4]
        |   |--TYPE -> TYPE [48:11]
        |   |   |--LITERAL_INT -> int [48:11]
        |   |   `--ARRAY_DECLARATOR -> [ [48:14]
        |   |       `--RBRACK -> ] [48:15]
        |   |--IDENT -> m6 [48:17]
        |   |--LPAREN -> ( [48:19]
        |   |--PARAMETERS -> PARAMETERS [48:20]
        |   |--RPAREN -> ) [48:20]
        |   `--SLIST -> { [48:22]
        |       |--LITERAL_RETURN -> return [48:23]
        |       |   |--EXPR -> EXPR [48:30]
        |       |   |   `--LITERAL_NULL -> null [48:30]
        |       |   `--SEMI -> ; [48:34]
        |       `--RCURLY -> } [48:35]
        |--METHOD_DEF -> METHOD_DEF [49:4]
        |   |--MODIFIERS -> MODIFIERS [49:4]
        |   |   `--LITERAL_PUBLIC -> public [49:4]
        |   |--TYPE -> TYPE [49:11]
        |   |   |--LITERAL_INT -> int [49:11]
        |   |   `--ARRAY_DECLARATOR -> [ [49:20]
        |   |       `--RBRACK -> ] [49:21]
        |   |--IDENT -> m7 [49:15]
        |   |--LPAREN -> ( [49:17]
        |   |--PARAMETERS -> PARAMETERS [49:18]
        |   |--RPAREN -> ) [49:18]
        |   `--SLIST -> { [49:23]
        |       |--LITERAL_RETURN -> return [49:24]
        |       |   |--EXPR -> EXPR [49:31]
        |       |   |   `--LITERAL_NULL -> null [49:31]
        |       |   `--SEMI -> ; [49:35]
        |       `--RCURLY -> } [49:36]
        |--METHOD_DEF -> METHOD_DEF [52:4]
        |   |--MODIFIERS -> MODIFIERS [52:4]
        |   |   `--LITERAL_PUBLIC -> public [52:4]
        |   |--TYPE -> TYPE [52:11]
        |   |   `--LITERAL_VOID -> void [52:11]
        |   |--IDENT -> m10 [52:16]
        |   |--LPAREN -> ( [52:19]
        |   |--PARAMETERS -> PARAMETERS [52:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [52:20]
        |   |       |--MODIFIERS -> MODIFIERS [52:20]
        |   |       |--TYPE -> TYPE [52:20]
        |   |       |   `--IDENT -> String [52:20]
        |   |       `--IDENT -> p1 [52:27]
        |   |--RPAREN -> ) [52:29]
        |   `--SLIST -> { [52:31]
        |       `--RCURLY -> } [52:32]
        |--METHOD_DEF -> METHOD_DEF [53:4]
        |   |--MODIFIERS -> MODIFIERS [53:4]
        |   |   `--LITERAL_PUBLIC -> public [53:4]
        |   |--TYPE -> TYPE [53:11]
        |   |   `--LITERAL_VOID -> void [53:11]
        |   |--IDENT -> m11 [53:16]
        |   |--LPAREN -> ( [53:19]
        |   |--PARAMETERS -> PARAMETERS [53:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [53:20]
        |   |       |--MODIFIERS -> MODIFIERS [53:20]
        |   |       |   `--FINAL -> final [53:20]
        |   |       |--TYPE -> TYPE [53:26]
        |   |       |   `--IDENT -> String [53:26]
        |   |       `--IDENT -> p1 [53:33]
        |   |--RPAREN -> ) [53:35]
        |   `--SLIST -> { [53:37]
        |       `--RCURLY -> } [53:38]
        |--METHOD_DEF -> METHOD_DEF [54:4]
        |   |--MODIFIERS -> MODIFIERS [54:4]
        |   |   `--LITERAL_PUBLIC -> public [54:4]
        |   |--TYPE -> TYPE [54:11]
        |   |   `--LITERAL_VOID -> void [54:11]
        |   |--IDENT -> m12 [54:16]
        |   |--LPAREN -> ( [54:19]
        |   |--PARAMETERS -> PARAMETERS [54:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [54:20]
        |   |       |--MODIFIERS -> MODIFIERS [54:20]
        |   |       |--TYPE -> TYPE [54:20]
        |   |       |   |--IDENT -> String [54:20]
        |   |       |   `--ARRAY_DECLARATOR -> [ [54:26]
        |   |       |       `--RBRACK -> ] [54:27]
        |   |       `--IDENT -> p1 [54:29]
        |   |--RPAREN -> ) [54:31]
        |   `--SLIST -> { [54:33]
        |       `--RCURLY -> } [54:34]
        |--METHOD_DEF -> METHOD_DEF [55:4]
        |   |--MODIFIERS -> MODIFIERS [55:4]
        |   |   `--LITERAL_PUBLIC -> public [55:4]
        |   |--TYPE -> TYPE [55:11]
        |   |   `--LITERAL_VOID -> void [55:11]
        |   |--IDENT -> m13 [55:16]
        |   |--LPAREN -> ( [55:19]
        |   |--PARAMETERS -> PARAMETERS [55:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [55:20]
        |   |       |--MODIFIERS -> MODIFIERS [55:20]
        |   |       |--TYPE -> TYPE [55:20]
        |   |       |   |--IDENT -> String [55:20]
        |   |       |   |--ARRAY_DECLARATOR -> [ [55:26]
        |   |       |   |   `--RBRACK -> ] [55:27]
        |   |       |   `--ARRAY_DECLARATOR -> [ [55:28]
        |   |       |       `--RBRACK -> ] [55:29]
        |   |       `--IDENT -> p1 [55:31]
        |   |--RPAREN -> ) [55:33]
        |   `--SLIST -> { [55:35]
        |       `--RCURLY -> } [55:36]
        |--METHOD_DEF -> METHOD_DEF [56:4]
        |   |--MODIFIERS -> MODIFIERS [56:4]
        |   |   `--LITERAL_PUBLIC -> public [56:4]
        |   |--TYPE -> TYPE [56:11]
        |   |   `--LITERAL_VOID -> void [56:11]
        |   |--IDENT -> m14 [56:16]
        |   |--LPAREN -> ( [56:19]
        |   |--PARAMETERS -> PARAMETERS [56:20]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [56:20]
        |   |   |   |--MODIFIERS -> MODIFIERS [56:20]
        |   |   |   |--TYPE -> TYPE [56:20]
        |   |   |   |   `--IDENT -> String [56:20]
        |   |   |   `--IDENT -> p1 [56:27]
        |   |   |--COMMA -> , [56:29]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [56:31]
        |   |       |--MODIFIERS -> MODIFIERS [56:31]
        |   |       |--TYPE -> TYPE [56:31]
        |   |       |   `--IDENT -> String [56:31]
        |   |       `--IDENT -> p2 [56:38]
        |   |--RPAREN -> ) [56:40]
        |   `--SLIST -> { [56:42]
        |       `--RCURLY -> } [56:43]
        |--METHOD_DEF -> METHOD_DEF [57:4]
        |   |--MODIFIERS -> MODIFIERS [57:4]
        |   |   `--LITERAL_PUBLIC -> public [57:4]
        |   |--TYPE -> TYPE [57:11]
        |   |   `--LITERAL_VOID -> void [57:11]
        |   |--IDENT -> m15 [57:16]
        |   |--LPAREN -> ( [57:19]
        |   |--PARAMETERS -> PARAMETERS [57:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [57:20]
        |   |       |--MODIFIERS -> MODIFIERS [57:20]
        |   |       |--TYPE -> TYPE [57:20]
        |   |       |   `--IDENT -> String [57:20]
        |   |       |--ELLIPSIS -> ... [57:26]
        |   |       `--IDENT -> p1 [57:30]
        |   |--RPAREN -> ) [57:32]
        |   `--SLIST -> { [57:34]
        |       `--RCURLY -> } [57:35]
        |--METHOD_DEF -> METHOD_DEF [58:4]
        |   |--MODIFIERS -> MODIFIERS [58:4]
        |   |   `--LITERAL_PUBLIC -> public [58:4]
        |   |--TYPE -> TYPE [58:11]
        |   |   `--LITERAL_VOID -> void [58:11]
        |   |--IDENT -> m16 [58:16]
        |   |--LPAREN -> ( [58:19]
        |   |--PARAMETERS -> PARAMETERS [58:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:20]
        |   |       |--MODIFIERS -> MODIFIERS [58:20]
        |   |       |--TYPE -> TYPE [58:20]
        |   |       |   |--IDENT -> String [58:20]
        |   |       |   `--ARRAY_DECLARATOR -> [ [58:26]
        |   |       |       `--RBRACK -> ] [58:27]
        |   |       |--ELLIPSIS -> ... [58:28]
        |   |       `--IDENT -> p1 [58:32]
        |   |--RPAREN -> ) [58:34]
        |   `--SLIST -> { [58:36]
        |       `--RCURLY -> } [58:37]
        |--METHOD_DEF -> METHOD_DEF [59:4]
        |   |--MODIFIERS -> MODIFIERS [59:4]
        |   |   `--LITERAL_PUBLIC -> public [59:4]
        |   |--TYPE -> TYPE [59:11]
        |   |   `--LITERAL_VOID -> void [59:11]
        |   |--IDENT -> m17 [59:16]
        |   |--LPAREN -> ( [59:19]
        |   |--PARAMETERS -> PARAMETERS [59:20]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [59:20]
        |   |   |   |--MODIFIERS -> MODIFIERS [59:20]
        |   |   |   |--TYPE -> TYPE [59:20]
        |   |   |   |   `--LITERAL_INT -> int [59:20]
        |   |   |   `--IDENT -> p1 [59:24]
        |   |   |--COMMA -> , [59:26]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [59:28]
        |   |       |--MODIFIERS -> MODIFIERS [59:28]
        |   |       |--TYPE -> TYPE [59:28]
        |   |       |   |--IDENT -> String [59:28]
        |   |       |   `--ARRAY_DECLARATOR -> [ [59:34]
        |   |       |       `--RBRACK -> ] [59:35]
        |   |       |--ELLIPSIS -> ... [59:36]
        |   |       `--IDENT -> p2 [59:40]
        |   |--RPAREN -> ) [59:42]
        |   `--SLIST -> { [59:44]
        |       `--RCURLY -> } [59:45]
        |--METHOD_DEF -> METHOD_DEF [62:4]
        |   |--MODIFIERS -> MODIFIERS [62:4]
        |   |   `--LITERAL_PUBLIC -> public [62:4]
        |   |--TYPE -> TYPE [62:11]
        |   |   `--LITERAL_VOID -> void [62:11]
        |   |--IDENT -> m18 [62:16]
        |   |--LPAREN -> ( [62:19]
        |   |--PARAMETERS -> PARAMETERS [62:20]
        |   |--RPAREN -> ) [62:20]
        |   |--LITERAL_THROWS -> throws [62:22]
        |   |   `--IDENT -> Exception [62:29]
        |   `--SLIST -> { [62:39]
        |       `--RCURLY -> } [62:40]
        |--METHOD_DEF -> METHOD_DEF [63:4]
        |   |--MODIFIERS -> MODIFIERS [63:4]
        |   |   `--LITERAL_PUBLIC -> public [63:4]
        |   |--TYPE -> TYPE [63:11]
        |   |   `--LITERAL_VOID -> void [63:11]
        |   |--IDENT -> m19 [63:16]
        |   |--LPAREN -> ( [63:19]
        |   |--PARAMETERS -> PARAMETERS [63:20]
        |   |--RPAREN -> ) [63:20]
        |   |--LITERAL_THROWS -> throws [63:22]
        |   |   |--IDENT -> IOException [63:29]
        |   |   |--COMMA -> , [63:40]
        |   |   `--IDENT -> Exception [63:42]
        |   `--SLIST -> { [63:52]
        |       `--RCURLY -> } [63:53]
        |--METHOD_DEF -> METHOD_DEF [66:4]
        |   |--MODIFIERS -> MODIFIERS [66:4]
        |   |   `--LITERAL_PUBLIC -> public [66:4]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [66:11]
        |   |   |--GENERIC_START -> < [66:11]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [66:12]
        |   |   |   `--IDENT -> T_$ [66:12]
        |   |   `--GENERIC_END -> > [66:15]
        |   |--TYPE -> TYPE [66:17]
        |   |   `--IDENT -> T_$ [66:17]
        |   |--IDENT -> m20 [66:21]
        |   |--LPAREN -> ( [66:24]
        |   |--PARAMETERS -> PARAMETERS [66:25]
        |   |--RPAREN -> ) [66:25]
        |   `--SLIST -> { [66:27]
        |       |--LITERAL_RETURN -> return [66:28]
        |       |   |--EXPR -> EXPR [66:35]
        |       |   |   `--LITERAL_NULL -> null [66:35]
        |       |   `--SEMI -> ; [66:39]
        |       `--RCURLY -> } [66:40]
        |--METHOD_DEF -> METHOD_DEF [67:4]
        |   |--MODIFIERS -> MODIFIERS [67:4]
        |   |   `--LITERAL_PUBLIC -> public [67:4]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [67:11]
        |   |   |--GENERIC_START -> < [67:11]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [67:12]
        |   |   |   `--IDENT -> $_T [67:12]
        |   |   `--GENERIC_END -> > [67:15]
        |   |--TYPE -> TYPE [67:17]
        |   |   `--IDENT -> $_T [67:17]
        |   |--IDENT -> m21 [67:21]
        |   |--LPAREN -> ( [67:24]
        |   |--PARAMETERS -> PARAMETERS [67:25]
        |   |--RPAREN -> ) [67:25]
        |   `--SLIST -> { [67:27]
        |       |--LITERAL_RETURN -> return [67:28]
        |       |   |--EXPR -> EXPR [67:35]
        |       |   |   `--LITERAL_NULL -> null [67:35]
        |       |   `--SEMI -> ; [67:39]
        |       `--RCURLY -> } [67:40]
        |--METHOD_DEF -> METHOD_DEF [68:4]
        |   |--MODIFIERS -> MODIFIERS [68:4]
        |   |   `--LITERAL_PUBLIC -> public [68:4]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [68:11]
        |   |   |--GENERIC_START -> < [68:11]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [68:12]
        |   |   |   |--IDENT -> T [68:12]
        |   |   |   `--TYPE_UPPER_BOUNDS -> extends [68:14]
        |   |   |       |--IDENT -> Enum [68:22]
        |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [68:26]
        |   |   |           |--GENERIC_START -> < [68:26]
        |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [68:27]
        |   |   |           |   `--IDENT -> T [68:27]
        |   |   |           `--GENERIC_END -> > [68:28]
        |   |   `--GENERIC_END -> > [68:29]
        |   |--TYPE -> TYPE [68:31]
        |   |   `--LITERAL_VOID -> void [68:31]
        |   |--IDENT -> m22 [68:36]
        |   |--LPAREN -> ( [68:39]
        |   |--PARAMETERS -> PARAMETERS [68:40]
        |   |--RPAREN -> ) [68:40]
        |   `--SLIST -> { [68:42]
        |       `--RCURLY -> } [68:43]
        |--METHOD_DEF -> METHOD_DEF [69:4]
        |   |--MODIFIERS -> MODIFIERS [69:4]
        |   |   `--LITERAL_PUBLIC -> public [69:4]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [69:11]
        |   |   |--GENERIC_START -> < [69:11]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [69:12]
        |   |   |   `--IDENT -> T [69:12]
        |   |   `--GENERIC_END -> > [69:13]
        |   |--TYPE -> TYPE [69:15]
        |   |   `--LITERAL_VOID -> void [69:15]
        |   |--IDENT -> m23 [69:20]
        |   |--LPAREN -> ( [69:23]
        |   |--PARAMETERS -> PARAMETERS [69:24]
        |   |--RPAREN -> ) [69:24]
        |   `--SLIST -> { [69:26]
        |       `--RCURLY -> } [69:27]
        |--SEMI -> ; [69:28]
        |--METHOD_DEF -> METHOD_DEF [70:4]
        |   |--MODIFIERS -> MODIFIERS [70:4]
        |   |   `--LITERAL_PUBLIC -> public [70:4]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [70:11]
        |   |   |--GENERIC_START -> < [70:11]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [70:12]
        |   |   |   |--IDENT -> T [70:12]
        |   |   |   `--TYPE_UPPER_BOUNDS -> extends [70:14]
        |   |   |       |--IDENT -> RuntimeException [70:22]
        |   |   |       |--TYPE_EXTENSION_AND -> & [70:39]
        |   |   |       `--DOT -> . [70:48]
        |   |   |           |--DOT -> . [70:45]
        |   |   |           |   |--IDENT -> java [70:41]
        |   |   |           |   `--IDENT -> io [70:46]
        |   |   |           `--IDENT -> Serializable [70:49]
        |   |   `--GENERIC_END -> > [70:61]
        |   |--TYPE -> TYPE [70:63]
        |   |   `--LITERAL_VOID -> void [70:63]
        |   |--IDENT -> m24 [70:68]
        |   |--LPAREN -> ( [70:71]
        |   |--PARAMETERS -> PARAMETERS [70:72]
        |   |--RPAREN -> ) [70:72]
        |   `--SLIST -> { [70:74]
        |       `--RCURLY -> } [70:75]
        |--METHOD_DEF -> METHOD_DEF [73:4]
        |   |--MODIFIERS -> MODIFIERS [73:4]
        |   |   |--ANNOTATION -> ANNOTATION [73:4]
        |   |   |   |--AT -> @ [73:4]
        |   |   |   |--IDENT -> SuppressWarnings [73:5]
        |   |   |   |--LPAREN -> ( [73:21]
        |   |   |   |--ANNOTATION_ARRAY_INIT -> { [73:22]
        |   |   |   |   `--RCURLY -> } [73:23]
        |   |   |   `--RPAREN -> ) [73:24]
        |   |   `--LITERAL_PUBLIC -> public [74:4]
        |   |--TYPE -> TYPE [74:11]
        |   |   `--LITERAL_VOID -> void [74:11]
        |   |--IDENT -> m50 [74:16]
        |   |--LPAREN -> ( [74:19]
        |   |--PARAMETERS -> PARAMETERS [74:20]
        |   |--RPAREN -> ) [74:20]
        |   `--SLIST -> { [74:22]
        |       `--RCURLY -> } [74:23]
        |--METHOD_DEF -> METHOD_DEF [75:4]
        |   |--MODIFIERS -> MODIFIERS [75:4]
        |   |   |--ANNOTATION -> ANNOTATION [75:4]
        |   |   |   |--AT -> @ [75:4]
        |   |   |   |--IDENT -> SuppressWarnings [75:5]
        |   |   |   |--LPAREN -> ( [75:21]
        |   |   |   |--ANNOTATION_ARRAY_INIT -> { [75:22]
        |   |   |   |   |--EXPR -> EXPR [75:23]
        |   |   |   |   |   `--STRING_LITERAL -> "1" [75:23]
        |   |   |   |   `--RCURLY -> } [75:26]
        |   |   |   `--RPAREN -> ) [75:27]
        |   |   `--LITERAL_PUBLIC -> public [76:4]
        |   |--TYPE -> TYPE [76:11]
        |   |   `--LITERAL_VOID -> void [76:11]
        |   |--IDENT -> m51 [76:16]
        |   |--LPAREN -> ( [76:19]
        |   |--PARAMETERS -> PARAMETERS [76:20]
        |   |--RPAREN -> ) [76:20]
        |   `--SLIST -> { [76:22]
        |       `--RCURLY -> } [76:23]
        |--METHOD_DEF -> METHOD_DEF [77:4]
        |   |--MODIFIERS -> MODIFIERS [77:4]
        |   |   |--ANNOTATION -> ANNOTATION [77:4]
        |   |   |   |--AT -> @ [77:4]
        |   |   |   |--IDENT -> SuppressWarnings [77:5]
        |   |   |   |--LPAREN -> ( [77:21]
        |   |   |   |--ANNOTATION_ARRAY_INIT -> { [77:22]
        |   |   |   |   |--EXPR -> EXPR [77:23]
        |   |   |   |   |   `--STRING_LITERAL -> "1" [77:23]
        |   |   |   |   |--COMMA -> , [77:26]
        |   |   |   |   |--EXPR -> EXPR [77:27]
        |   |   |   |   |   `--STRING_LITERAL -> "2" [77:27]
        |   |   |   |   `--RCURLY -> } [77:30]
        |   |   |   `--RPAREN -> ) [77:31]
        |   |   `--LITERAL_PUBLIC -> public [78:4]
        |   |--TYPE -> TYPE [78:11]
        |   |   `--LITERAL_VOID -> void [78:11]
        |   |--IDENT -> m52 [78:16]
        |   |--LPAREN -> ( [78:19]
        |   |--PARAMETERS -> PARAMETERS [78:20]
        |   |--RPAREN -> ) [78:20]
        |   `--SLIST -> { [78:22]
        |       `--RCURLY -> } [78:23]
        |--METHOD_DEF -> METHOD_DEF [79:4]
        |   |--MODIFIERS -> MODIFIERS [79:4]
        |   |   |--ANNOTATION -> ANNOTATION [79:4]
        |   |   |   |--AT -> @ [79:4]
        |   |   |   |--IDENT -> SuppressWarnings [79:5]
        |   |   |   |--LPAREN -> ( [79:21]
        |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [79:22]
        |   |   |   |   |--IDENT -> value [79:22]
        |   |   |   |   |--ASSIGN -> = [79:27]
        |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [79:28]
        |   |   |   |       |--EXPR -> EXPR [79:29]
        |   |   |   |       |   `--STRING_LITERAL -> "1" [79:29]
        |   |   |   |       `--RCURLY -> } [79:32]
        |   |   |   `--RPAREN -> ) [79:33]
        |   |   `--LITERAL_PUBLIC -> public [80:4]
        |   |--TYPE -> TYPE [80:11]
        |   |   `--LITERAL_VOID -> void [80:11]
        |   |--IDENT -> m53 [80:16]
        |   |--LPAREN -> ( [80:19]
        |   |--PARAMETERS -> PARAMETERS [80:20]
        |   |--RPAREN -> ) [80:20]
        |   `--SLIST -> { [80:22]
        |       `--RCURLY -> } [80:23]
        |--METHOD_DEF -> METHOD_DEF [81:4]
        |   |--MODIFIERS -> MODIFIERS [81:4]
        |   |   |--ANNOTATION -> ANNOTATION [81:4]
        |   |   |   |--AT -> @ [81:4]
        |   |   |   |--IDENT -> SuppressWarnings [81:5]
        |   |   |   |--LPAREN -> ( [81:21]
        |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [81:22]
        |   |   |   |   |--IDENT -> value [81:22]
        |   |   |   |   |--ASSIGN -> = [81:27]
        |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [81:28]
        |   |   |   |       |--EXPR -> EXPR [81:29]
        |   |   |   |       |   `--STRING_LITERAL -> "1" [81:29]
        |   |   |   |       |--COMMA -> , [81:32]
        |   |   |   |       `--RCURLY -> } [81:33]
        |   |   |   `--RPAREN -> ) [81:34]
        |   |   `--LITERAL_PUBLIC -> public [82:4]
        |   |--TYPE -> TYPE [82:11]
        |   |   `--LITERAL_VOID -> void [82:11]
        |   |--IDENT -> m54 [82:16]
        |   |--LPAREN -> ( [82:19]
        |   |--PARAMETERS -> PARAMETERS [82:20]
        |   |--RPAREN -> ) [82:20]
        |   `--SLIST -> { [82:22]
        |       `--RCURLY -> } [82:23]
        |--METHOD_DEF -> METHOD_DEF [83:4]
        |   |--MODIFIERS -> MODIFIERS [83:4]
        |   |   |--ANNOTATION -> ANNOTATION [83:4]
        |   |   |   |--AT -> @ [83:4]
        |   |   |   |--IDENT -> SuppressWarnings [83:5]
        |   |   |   |--LPAREN -> ( [83:21]
        |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [83:22]
        |   |   |   |   |--IDENT -> value [83:22]
        |   |   |   |   |--ASSIGN -> = [83:27]
        |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [83:28]
        |   |   |   |       |--EXPR -> EXPR [83:29]
        |   |   |   |       |   `--STRING_LITERAL -> "1" [83:29]
        |   |   |   |       |--COMMA -> , [83:32]
        |   |   |   |       |--EXPR -> EXPR [83:33]
        |   |   |   |       |   `--STRING_LITERAL -> "2" [83:33]
        |   |   |   |       `--RCURLY -> } [83:36]
        |   |   |   `--RPAREN -> ) [83:37]
        |   |   `--LITERAL_PUBLIC -> public [84:4]
        |   |--TYPE -> TYPE [84:11]
        |   |   `--LITERAL_VOID -> void [84:11]
        |   |--IDENT -> m55 [84:16]
        |   |--LPAREN -> ( [84:19]
        |   |--PARAMETERS -> PARAMETERS [84:20]
        |   |--RPAREN -> ) [84:20]
        |   `--SLIST -> { [84:22]
        |       `--RCURLY -> } [84:23]
        |--METHOD_DEF -> METHOD_DEF [85:4]
        |   |--MODIFIERS -> MODIFIERS [85:4]
        |   |   |--ANNOTATION -> ANNOTATION [85:4]
        |   |   |   |--AT -> @ [85:4]
        |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [85:5]
        |   |   |   |--LPAREN -> ( [85:35]
        |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [85:36]
        |   |   |   |   |--IDENT -> m1 [85:36]
        |   |   |   |   |--ASSIGN -> = [85:38]
        |   |   |   |   `--EXPR -> EXPR [85:39]
        |   |   |   |       `--STRING_LITERAL -> "1" [85:39]
        |   |   |   |--COMMA -> , [85:42]
        |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [85:44]
        |   |   |   |   |--IDENT -> m2 [85:44]
        |   |   |   |   |--ASSIGN -> = [85:46]
        |   |   |   |   `--EXPR -> EXPR [85:47]
        |   |   |   |       `--STRING_LITERAL -> "2" [85:47]
        |   |   |   `--RPAREN -> ) [85:50]
        |   |   `--LITERAL_PUBLIC -> public [86:4]
        |   |--TYPE -> TYPE [86:11]
        |   |   `--LITERAL_VOID -> void [86:11]
        |   |--IDENT -> m56 [86:16]
        |   |--LPAREN -> ( [86:19]
        |   |--PARAMETERS -> PARAMETERS [86:20]
        |   |--RPAREN -> ) [86:20]
        |   `--SLIST -> { [86:22]
        |       `--RCURLY -> } [86:23]
        |--METHOD_DEF -> METHOD_DEF [87:4]
        |   |--MODIFIERS -> MODIFIERS [87:4]
        |   |   |--ANNOTATION -> ANNOTATION [87:4]
        |   |   |   |--AT -> @ [87:4]
        |   |   |   |--IDENT -> ComplexAnnotation [87:5]
        |   |   |   |--LPAREN -> ( [87:22]
        |   |   |   |--ANNOTATION_ARRAY_INIT -> { [87:23]
        |   |   |   |   |--ANNOTATION -> ANNOTATION [88:12]
        |   |   |   |   |   |--AT -> @ [88:12]
        |   |   |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [88:13]
        |   |   |   |   |   |--LPAREN -> ( [88:43]
        |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [88:44]
        |   |   |   |   |   |   |--IDENT -> m1 [88:44]
        |   |   |   |   |   |   |--ASSIGN -> = [88:47]
        |   |   |   |   |   |   `--EXPR -> EXPR [88:49]
        |   |   |   |   |   |       `--STRING_LITERAL -> "1" [88:49]
        |   |   |   |   |   |--COMMA -> , [88:52]
        |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [88:54]
        |   |   |   |   |   |   |--IDENT -> m2 [88:54]
        |   |   |   |   |   |   |--ASSIGN -> = [88:57]
        |   |   |   |   |   |   `--EXPR -> EXPR [88:59]
        |   |   |   |   |   |       `--STRING_LITERAL -> "" [88:59]
        |   |   |   |   |   `--RPAREN -> ) [88:61]
        |   |   |   |   |--COMMA -> , [88:62]
        |   |   |   |   |--ANNOTATION -> ANNOTATION [89:12]
        |   |   |   |   |   |--AT -> @ [89:12]
        |   |   |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [89:13]
        |   |   |   |   |   |--LPAREN -> ( [89:43]
        |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [89:44]
        |   |   |   |   |   |   |--IDENT -> m1 [89:44]
        |   |   |   |   |   |   |--ASSIGN -> = [89:47]
        |   |   |   |   |   |   `--EXPR -> EXPR [89:49]
        |   |   |   |   |   |       `--STRING_LITERAL -> "1" [89:49]
        |   |   |   |   |   |--COMMA -> , [89:52]
        |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [89:54]
        |   |   |   |   |   |   |--IDENT -> m2 [89:54]
        |   |   |   |   |   |   |--ASSIGN -> = [89:57]
        |   |   |   |   |   |   `--EXPR -> EXPR [89:59]
        |   |   |   |   |   |       `--STRING_LITERAL -> "" [89:59]
        |   |   |   |   |   `--RPAREN -> ) [89:61]
        |   |   |   |   `--RCURLY -> } [90:4]
        |   |   |   `--RPAREN -> ) [90:5]
        |   |   `--LITERAL_PUBLIC -> public [91:4]
        |   |--TYPE -> TYPE [91:11]
        |   |   `--LITERAL_VOID -> void [91:11]
        |   |--IDENT -> m57 [91:16]
        |   |--LPAREN -> ( [91:19]
        |   |--PARAMETERS -> PARAMETERS [91:20]
        |   |--RPAREN -> ) [91:20]
        |   `--SLIST -> { [91:22]
        |       `--RCURLY -> } [91:23]
        |--METHOD_DEF -> METHOD_DEF [92:4]
        |   |--MODIFIERS -> MODIFIERS [92:4]
        |   |   `--LITERAL_PUBLIC -> public [92:4]
        |   |--TYPE -> TYPE [92:11]
        |   |   `--LITERAL_VOID -> void [92:11]
        |   |--IDENT -> m58 [92:16]
        |   |--LPAREN -> ( [92:19]
        |   |--PARAMETERS -> PARAMETERS [92:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [92:20]
        |   |       |--MODIFIERS -> MODIFIERS [92:20]
        |   |       |   `--ANNOTATION -> ANNOTATION [92:20]
        |   |       |       |--AT -> @ [92:20]
        |   |       |       `--IDENT -> Deprecated [92:21]
        |   |       |--TYPE -> TYPE [92:32]
        |   |       |   `--IDENT -> String [92:32]
        |   |       `--IDENT -> s [92:39]
        |   |--RPAREN -> ) [92:40]
        |   `--SLIST -> { [92:42]
        |       `--RCURLY -> } [92:43]
        |--METHOD_DEF -> METHOD_DEF [93:4]
        |   |--MODIFIERS -> MODIFIERS [93:4]
        |   |   `--LITERAL_PUBLIC -> public [93:4]
        |   |--TYPE -> TYPE [93:11]
        |   |   `--LITERAL_VOID -> void [93:11]
        |   |--IDENT -> m59 [93:16]
        |   |--LPAREN -> ( [93:19]
        |   |--PARAMETERS -> PARAMETERS [93:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [93:20]
        |   |       |--MODIFIERS -> MODIFIERS [93:20]
        |   |       |   |--FINAL -> final [93:20]
        |   |       |   `--ANNOTATION -> ANNOTATION [93:26]
        |   |       |       |--AT -> @ [93:26]
        |   |       |       `--IDENT -> Deprecated [93:27]
        |   |       |--TYPE -> TYPE [93:38]
        |   |       |   `--IDENT -> List [93:38]
        |   |       `--IDENT -> l [93:43]
        |   |--RPAREN -> ) [93:44]
        |   `--SLIST -> { [93:46]
        |       `--RCURLY -> } [93:47]
        |--INSTANCE_INIT -> INSTANCE_INIT [96:4]
        |   `--SLIST -> { [96:4]
        |       `--RCURLY -> } [96:5]
        |--SEMI -> ; [97:4]
        |--METHOD_DEF -> METHOD_DEF [100:4]
        |   |--MODIFIERS -> MODIFIERS [100:4]
        |   |   `--LITERAL_PUBLIC -> public [100:4]
        |   |--TYPE -> TYPE [100:11]
        |   |   `--LITERAL_VOID -> void [100:11]
        |   |--IDENT -> instructions [100:16]
        |   |--LPAREN -> ( [100:28]
        |   |--PARAMETERS -> PARAMETERS [100:29]
        |   |--RPAREN -> ) [100:29]
        |   |--LITERAL_THROWS -> throws [100:31]
        |   |   `--IDENT -> Exception [100:38]
        |   `--SLIST -> { [100:48]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [102:8]
        |       |   |--MODIFIERS -> MODIFIERS [102:8]
        |       |   |--TYPE -> TYPE [102:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [102:8]
        |       |   |--IDENT -> b [102:16]
        |       |   `--ASSIGN -> = [102:18]
        |       |       `--EXPR -> EXPR [102:34]
        |       |           `--GT -> > [102:34]
        |       |               |--METHOD_CALL -> ( [102:31]
        |       |               |   |--DOT -> . [102:24]
        |       |               |   |   |--IDENT -> Math [102:20]
        |       |               |   |   `--IDENT -> random [102:25]
        |       |               |   |--ELIST -> ELIST [102:32]
        |       |               |   `--RPAREN -> ) [102:32]
        |       |               `--NUM_INT -> 0 [102:36]
        |       |--SEMI -> ; [102:37]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [105:8]
        |       |   |--MODIFIERS -> MODIFIERS [105:8]
        |       |   |--TYPE -> TYPE [105:8]
        |       |   |   `--LITERAL_BYTE -> byte [105:8]
        |       |   `--IDENT -> vbyte [105:13]
        |       |--SEMI -> ; [105:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [106:8]
        |       |   |--MODIFIERS -> MODIFIERS [106:8]
        |       |   |--TYPE -> TYPE [106:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [106:8]
        |       |   `--IDENT -> vboolean [106:16]
        |       |--SEMI -> ; [106:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [107:8]
        |       |   |--MODIFIERS -> MODIFIERS [107:8]
        |       |   |--TYPE -> TYPE [107:8]
        |       |   |   `--LITERAL_CHAR -> char [107:8]
        |       |   `--IDENT -> vchar [107:13]
        |       |--SEMI -> ; [107:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [108:8]
        |       |   |--MODIFIERS -> MODIFIERS [108:8]
        |       |   |--TYPE -> TYPE [108:8]
        |       |   |   `--LITERAL_SHORT -> short [108:8]
        |       |   `--IDENT -> vshort [108:14]
        |       |--SEMI -> ; [108:20]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [109:8]
        |       |   |--MODIFIERS -> MODIFIERS [109:8]
        |       |   |--TYPE -> TYPE [109:8]
        |       |   |   `--LITERAL_INT -> int [109:8]
        |       |   `--IDENT -> vint [109:12]
        |       |--SEMI -> ; [109:16]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [110:8]
        |       |   |--MODIFIERS -> MODIFIERS [110:8]
        |       |   |--TYPE -> TYPE [110:8]
        |       |   |   `--LITERAL_LONG -> long [110:8]
        |       |   `--IDENT -> vlong [110:13]
        |       |--SEMI -> ; [110:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [111:8]
        |       |   |--MODIFIERS -> MODIFIERS [111:8]
        |       |   |--TYPE -> TYPE [111:8]
        |       |   |   `--LITERAL_FLOAT -> float [111:8]
        |       |   `--IDENT -> vfloat [111:14]
        |       |--SEMI -> ; [111:20]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [112:8]
        |       |   |--MODIFIERS -> MODIFIERS [112:8]
        |       |   |--TYPE -> TYPE [112:8]
        |       |   |   `--LITERAL_DOUBLE -> double [112:8]
        |       |   `--IDENT -> vdouble [112:15]
        |       |--SEMI -> ; [112:22]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
        |       |   |--MODIFIERS -> MODIFIERS [113:8]
        |       |   |--TYPE -> TYPE [113:8]
        |       |   |   |--LITERAL_INT -> int [113:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [113:11]
        |       |   |       `--RBRACK -> ] [113:12]
        |       |   `--IDENT -> varray [113:14]
        |       |--SEMI -> ; [113:20]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [114:8]
        |       |   |--MODIFIERS -> MODIFIERS [114:8]
        |       |   |--TYPE -> TYPE [114:8]
        |       |   |   |--LITERAL_INT -> int [114:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [114:19]
        |       |   |       `--RBRACK -> ] [114:20]
        |       |   `--IDENT -> varray2 [114:12]
        |       |--SEMI -> ; [114:21]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [115:8]
        |       |   |--MODIFIERS -> MODIFIERS [115:8]
        |       |   |--TYPE -> TYPE [115:8]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [115:8]
        |       |   |--IDENT -> test1 [115:16]
        |       |   `--ASSIGN -> = [115:22]
        |       |       `--EXPR -> EXPR [115:24]
        |       |           `--LITERAL_TRUE -> true [115:24]
        |       |--SEMI -> ; [115:28]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [118:8]
        |       |   |--MODIFIERS -> MODIFIERS [118:8]
        |       |   |--TYPE -> TYPE [118:8]
        |       |   |   `--IDENT -> String [118:8]
        |       |   `--IDENT -> vstring [118:15]
        |       |--SEMI -> ; [118:22]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [119:8]
        |       |   |--MODIFIERS -> MODIFIERS [119:8]
        |       |   |--TYPE -> TYPE [119:8]
        |       |   |   |--IDENT -> List [119:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [119:12]
        |       |   |       |--GENERIC_START -> < [119:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [119:13]
        |       |   |       |   `--IDENT -> String [119:13]
        |       |   |       `--GENERIC_END -> > [119:19]
        |       |   `--IDENT -> vlist [119:21]
        |       |--SEMI -> ; [119:26]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [120:8]
        |       |   |--MODIFIERS -> MODIFIERS [120:8]
        |       |   |--TYPE -> TYPE [120:8]
        |       |   |   |--IDENT -> Map [120:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [120:11]
        |       |   |       |--GENERIC_START -> < [120:11]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:12]
        |       |   |       |   `--IDENT -> String [120:12]
        |       |   |       |--COMMA -> , [120:18]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:20]
        |       |   |       |   |--IDENT -> String [120:20]
        |       |   |       |   `--ARRAY_DECLARATOR -> [ [120:26]
        |       |   |       |       `--RBRACK -> ] [120:27]
        |       |   |       `--GENERIC_END -> > [120:28]
        |       |   `--IDENT -> vmap [120:30]
        |       |--SEMI -> ; [120:34]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [121:8]
        |       |   |--MODIFIERS -> MODIFIERS [121:8]
        |       |   |--TYPE -> TYPE [121:8]
        |       |   |   |--LITERAL_INT -> int [121:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [121:11]
        |       |   |       `--RBRACK -> ] [121:12]
        |       |   |--IDENT -> test2 [121:14]
        |       |   `--ASSIGN -> = [121:20]
        |       |       `--ARRAY_INIT -> { [121:22]
        |       |           `--RCURLY -> } [121:23]
        |       |--SEMI -> ; [121:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [122:8]
        |       |   |--MODIFIERS -> MODIFIERS [122:8]
        |       |   |--TYPE -> TYPE [122:8]
        |       |   |   |--IDENT -> List [122:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [122:12]
        |       |   |       |--GENERIC_START -> < [122:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [122:13]
        |       |   |       |   |--LITERAL_CHAR -> char [122:13]
        |       |   |       |   `--ARRAY_DECLARATOR -> [ [122:17]
        |       |   |       |       `--RBRACK -> ] [122:18]
        |       |   |       `--GENERIC_END -> > [122:19]
        |       |   `--IDENT -> test3 [122:21]
        |       |--SEMI -> ; [122:26]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [123:8]
        |       |   |--MODIFIERS -> MODIFIERS [123:8]
        |       |   |--TYPE -> TYPE [123:8]
        |       |   |   |--IDENT -> Class [123:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [123:13]
        |       |   |       |--GENERIC_START -> < [123:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [123:14]
        |       |   |       |   `--WILDCARD_TYPE -> ? [123:14]
        |       |   |       `--GENERIC_END -> > [123:15]
        |       |   `--IDENT -> test4 [123:17]
        |       |--SEMI -> ; [123:22]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [124:8]
        |       |   |--MODIFIERS -> MODIFIERS [124:8]
        |       |   |--TYPE -> TYPE [124:8]
        |       |   |   |--IDENT -> List [124:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [124:12]
        |       |   |       |--GENERIC_START -> < [124:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:13]
        |       |   |       |   |--WILDCARD_TYPE -> ? [124:13]
        |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [124:15]
        |       |   |       |       `--IDENT -> InputRegressionJavaClass1 [124:23]
        |       |   |       `--GENERIC_END -> > [124:48]
        |       |   `--IDENT -> test5 [124:50]
        |       |--SEMI -> ; [124:55]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [125:8]
        |       |   |--MODIFIERS -> MODIFIERS [125:8]
        |       |   |--TYPE -> TYPE [125:8]
        |       |   |   |--IDENT -> List [125:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [125:12]
        |       |   |       |--GENERIC_START -> < [125:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:13]
        |       |   |       |   |--WILDCARD_TYPE -> ? [125:13]
        |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [125:15]
        |       |   |       |       |--IDENT -> List [125:23]
        |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [125:27]
        |       |   |       |           |--GENERIC_START -> < [125:27]
        |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:28]
        |       |   |       |           |   `--IDENT -> Object [125:28]
        |       |   |       |           `--GENERIC_END -> > [125:34]
        |       |   |       `--GENERIC_END -> > [125:35]
        |       |   `--IDENT -> test6 [125:37]
        |       |--SEMI -> ; [125:42]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [126:8]
        |       |   |--MODIFIERS -> MODIFIERS [126:8]
        |       |   |--TYPE -> TYPE [126:8]
        |       |   |   |--IDENT -> List [126:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:12]
        |       |   |       |--GENERIC_START -> < [126:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:13]
        |       |   |       |   |--WILDCARD_TYPE -> ? [126:13]
        |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [126:15]
        |       |   |       |       |--IDENT -> List [126:23]
        |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:27]
        |       |   |       |           |--GENERIC_START -> < [126:27]
        |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:28]
        |       |   |       |           |   |--IDENT -> List [126:28]
        |       |   |       |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:32]
        |       |   |       |           |       |--GENERIC_START -> < [126:32]
        |       |   |       |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:33]
        |       |   |       |           |       |   `--IDENT -> Object [126:33]
        |       |   |       |           |       `--GENERIC_END -> > [126:39]
        |       |   |       |           `--GENERIC_END -> > [126:40]
        |       |   |       `--GENERIC_END -> > [126:41]
        |       |   `--IDENT -> test7 [126:43]
        |       |--SEMI -> ; [126:48]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [127:8]
        |       |   |--MODIFIERS -> MODIFIERS [127:8]
        |       |   |--TYPE -> TYPE [127:8]
        |       |   |   |--IDENT -> List [127:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [127:12]
        |       |   |       |--GENERIC_START -> < [127:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [127:13]
        |       |   |       |   |--WILDCARD_TYPE -> ? [127:13]
        |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [127:15]
        |       |   |       |       |--LITERAL_INT -> int [127:23]
        |       |   |       |       `--ARRAY_DECLARATOR -> [ [127:26]
        |       |   |       |           `--RBRACK -> ] [127:27]
        |       |   |       `--GENERIC_END -> > [127:28]
        |       |   `--IDENT -> test8 [127:30]
        |       |--SEMI -> ; [127:35]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [128:8]
        |       |   |--MODIFIERS -> MODIFIERS [128:8]
        |       |   |--TYPE -> TYPE [128:8]
        |       |   |   |--IDENT -> List [128:8]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [128:12]
        |       |   |       |--GENERIC_START -> < [128:12]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [128:13]
        |       |   |       |   |--WILDCARD_TYPE -> ? [128:13]
        |       |   |       |   `--TYPE_LOWER_BOUNDS -> super [128:15]
        |       |   |       |       `--IDENT -> InputRegressionJavaClass1 [128:21]
        |       |   |       `--GENERIC_END -> > [128:46]
        |       |   `--IDENT -> test9 [128:48]
        |       |--SEMI -> ; [128:53]
        |       |--EXPR -> EXPR [131:17]
        |       |   `--ASSIGN -> = [131:17]
        |       |       |--IDENT -> vboolean [131:8]
        |       |       `--LITERAL_TRUE -> true [131:19]
        |       |--SEMI -> ; [131:23]
        |       |--EXPR -> EXPR [132:17]
        |       |   `--ASSIGN -> = [132:17]
        |       |       |--IDENT -> vboolean [132:8]
        |       |       `--LITERAL_FALSE -> false [132:19]
        |       |--SEMI -> ; [132:24]
        |       |--EXPR -> EXPR [133:14]
        |       |   `--ASSIGN -> = [133:14]
        |       |       |--IDENT -> vchar [133:8]
        |       |       `--CHAR_LITERAL -> ' ' [133:16]
        |       |--SEMI -> ; [133:19]
        |       |--EXPR -> EXPR [134:14]
        |       |   `--ASSIGN -> = [134:14]
        |       |       |--IDENT -> vchar [134:8]
        |       |       `--CHAR_LITERAL -> '"' [134:16]
        |       |--SEMI -> ; [134:19]
        |       |--EXPR -> EXPR [135:14]
        |       |   `--ASSIGN -> = [135:14]
        |       |       |--IDENT -> vchar [135:8]
        |       |       `--CHAR_LITERAL -> '\0' [135:16]
        |       |--SEMI -> ; [135:20]
        |       |--EXPR -> EXPR [136:14]
        |       |   `--ASSIGN -> = [136:14]
        |       |       |--IDENT -> vchar [136:8]
        |       |       `--CHAR_LITERAL -> '\'' [136:16]
        |       |--SEMI -> ; [136:20]
        |       |--EXPR -> EXPR [137:14]
        |       |   `--ASSIGN -> = [137:14]
        |       |       |--IDENT -> vchar [137:8]
        |       |       `--CHAR_LITERAL -> '\n' [137:16]
        |       |--SEMI -> ; [137:20]
        |       |--EXPR -> EXPR [138:14]
        |       |   `--ASSIGN -> = [138:14]
        |       |       |--IDENT -> vchar [138:8]
        |       |       `--CHAR_LITERAL -> '\r' [138:16]
        |       |--SEMI -> ; [138:20]
        |       |--EXPR -> EXPR [139:14]
        |       |   `--ASSIGN -> = [139:14]
        |       |       |--IDENT -> vchar [139:8]
        |       |       `--CHAR_LITERAL -> '\t' [139:16]
        |       |--SEMI -> ; [139:20]
        |       |--EXPR -> EXPR [140:14]
        |       |   `--ASSIGN -> = [140:14]
        |       |       |--IDENT -> vchar [140:8]
        |       |       `--CHAR_LITERAL -> '\b' [140:16]
        |       |--SEMI -> ; [140:20]
        |       |--EXPR -> EXPR [141:14]
        |       |   `--ASSIGN -> = [141:14]
        |       |       |--IDENT -> vchar [141:8]
        |       |       `--CHAR_LITERAL -> '\f' [141:16]
        |       |--SEMI -> ; [141:20]
        |       |--EXPR -> EXPR [142:14]
        |       |   `--ASSIGN -> = [142:14]
        |       |       |--IDENT -> vchar [142:8]
        |       |       `--CHAR_LITERAL -> '\"' [142:16]
        |       |--SEMI -> ; [142:20]
        |       |--EXPR -> EXPR [143:14]
        |       |   `--ASSIGN -> = [143:14]
        |       |       |--IDENT -> vchar [143:8]
        |       |       `--CHAR_LITERAL -> '\'' [143:16]
        |       |--SEMI -> ; [143:20]
        |       |--EXPR -> EXPR [144:14]
        |       |   `--ASSIGN -> = [144:14]
        |       |       |--IDENT -> vchar [144:8]
        |       |       `--CHAR_LITERAL -> '\\' [144:16]
        |       |--SEMI -> ; [144:20]
        |       |--EXPR -> EXPR [145:14]
        |       |   `--ASSIGN -> = [145:14]
        |       |       |--IDENT -> vchar [145:8]
        |       |       `--CHAR_LITERAL -> '\00' [145:16]
        |       |--SEMI -> ; [145:21]
        |       |--EXPR -> EXPR [146:14]
        |       |   `--ASSIGN -> = [146:14]
        |       |       |--IDENT -> vchar [146:8]
        |       |       `--CHAR_LITERAL -> '\013' [146:16]
        |       |--SEMI -> ; [146:22]
        |       |--EXPR -> EXPR [147:14]
        |       |   `--ASSIGN -> = [147:14]
        |       |       |--IDENT -> vchar [147:8]
        |       |       `--CHAR_LITERAL -> '\4' [147:16]
        |       |--SEMI -> ; [147:20]
        |       |--EXPR -> EXPR [148:14]
        |       |   `--ASSIGN -> = [148:14]
        |       |       |--IDENT -> vchar [148:8]
        |       |       `--CHAR_LITERAL -> '\40' [148:16]
        |       |--SEMI -> ; [148:21]
        |       |--EXPR -> EXPR [149:14]
        |       |   `--ASSIGN -> = [149:14]
        |       |       |--IDENT -> vchar [149:8]
        |       |       `--CHAR_LITERAL -> '\u0000' [149:16]
        |       |--SEMI -> ; [149:24]
        |       |--EXPR -> EXPR [150:14]
        |       |   `--ASSIGN -> = [150:14]
        |       |       |--IDENT -> vchar [150:8]
        |       |       `--CHAR_LITERAL -> '\u1234' [150:16]
        |       |--SEMI -> ; [150:24]
        |       |--EXPR -> EXPR [151:14]
        |       |   `--ASSIGN -> = [151:14]
        |       |       |--IDENT -> vchar [151:8]
        |       |       `--CHAR_LITERAL -> '\u005C\u005C' [151:16]
        |       |--SEMI -> ; [151:30]
        |       |--EXPR -> EXPR [152:14]
        |       |   `--ASSIGN -> = [152:14]
        |       |       |--IDENT -> vchar [152:8]
        |       |       `--CHAR_LITERAL -> '\u005c\u005c' [152:16]
        |       |--SEMI -> ; [152:30]
        |       |--EXPR -> EXPR [153:14]
        |       |   `--ASSIGN -> = [153:14]
        |       |       |--IDENT -> vchar [153:8]
        |       |       `--CHAR_LITERAL -> '\uu005C\uuuuu005C' [153:16]
        |       |--SEMI -> ; [153:35]
        |       |--EXPR -> EXPR [154:14]
        |       |   `--ASSIGN -> = [154:14]
        |       |       |--IDENT -> vchar [154:8]
        |       |       `--CHAR_LITERAL -> '\u005cn' [154:16]
        |       |--SEMI -> ; [154:25]
        |       |--EXPR -> EXPR [155:14]
        |       |   `--ASSIGN -> = [155:14]
        |       |       |--IDENT -> vchar [155:8]
        |       |       `--CHAR_LITERAL -> '\u005cr' [155:16]
        |       |--SEMI -> ; [155:25]
        |       |--EXPR -> EXPR [156:14]
        |       |   `--ASSIGN -> = [156:14]
        |       |       |--IDENT -> vchar [156:8]
        |       |       `--CHAR_LITERAL -> '\u005ct' [156:16]
        |       |--SEMI -> ; [156:25]
        |       |--EXPR -> EXPR [157:14]
        |       |   `--ASSIGN -> = [157:14]
        |       |       |--IDENT -> vchar [157:8]
        |       |       `--CHAR_LITERAL -> '\u005cb' [157:16]
        |       |--SEMI -> ; [157:25]
        |       |--EXPR -> EXPR [158:14]
        |       |   `--ASSIGN -> = [158:14]
        |       |       |--IDENT -> vchar [158:8]
        |       |       `--CHAR_LITERAL -> '\u005cf' [158:16]
        |       |--SEMI -> ; [158:25]
        |       |--EXPR -> EXPR [159:14]
        |       |   `--ASSIGN -> = [159:14]
        |       |       |--IDENT -> vchar [159:8]
        |       |       `--CHAR_LITERAL -> '\u005c"' [159:16]
        |       |--SEMI -> ; [159:25]
        |       |--EXPR -> EXPR [160:14]
        |       |   `--ASSIGN -> = [160:14]
        |       |       |--IDENT -> vchar [160:8]
        |       |       `--CHAR_LITERAL -> '\u005c'' [160:16]
        |       |--SEMI -> ; [160:25]
        |       |--EXPR -> EXPR [161:14]
        |       |   `--ASSIGN -> = [161:14]
        |       |       |--IDENT -> vchar [161:8]
        |       |       `--CHAR_LITERAL -> '\u005c\' [161:16]
        |       |--SEMI -> ; [161:25]
        |       |--EXPR -> EXPR [162:13]
        |       |   `--ASSIGN -> = [162:13]
        |       |       |--IDENT -> vint [162:8]
        |       |       `--NUM_INT -> 0 [162:15]
        |       |--SEMI -> ; [162:16]
        |       |--EXPR -> EXPR [163:13]
        |       |   `--ASSIGN -> = [163:13]
        |       |       |--IDENT -> vint [163:8]
        |       |       `--UNARY_MINUS -> - [163:15]
        |       |           `--NUM_INT -> 1 [163:16]
        |       |--SEMI -> ; [163:17]
        |       |--EXPR -> EXPR [164:13]
        |       |   `--ASSIGN -> = [164:13]
        |       |       |--IDENT -> vint [164:8]
        |       |       `--UNARY_PLUS -> + [164:15]
        |       |           `--NUM_INT -> 1 [164:16]
        |       |--SEMI -> ; [164:17]
        |       |--EXPR -> EXPR [165:13]
        |       |   `--ASSIGN -> = [165:13]
        |       |       |--IDENT -> vint [165:8]
        |       |       `--NUM_INT -> 100_000 [165:15]
        |       |--SEMI -> ; [165:22]
        |       |--EXPR -> EXPR [166:13]
        |       |   `--ASSIGN -> = [166:13]
        |       |       |--IDENT -> vint [166:8]
        |       |       `--NUM_INT -> 0x00 [166:15]
        |       |--SEMI -> ; [166:19]
        |       |--EXPR -> EXPR [167:13]
        |       |   `--ASSIGN -> = [167:13]
        |       |       |--IDENT -> vint [167:8]
        |       |       `--NUM_INT -> 0x12345678 [167:15]
        |       |--SEMI -> ; [167:25]
        |       |--EXPR -> EXPR [168:13]
        |       |   `--ASSIGN -> = [168:13]
        |       |       |--IDENT -> vint [168:8]
        |       |       `--NUM_INT -> 0X9 [168:15]
        |       |--SEMI -> ; [168:18]
        |       |--EXPR -> EXPR [169:13]
        |       |   `--ASSIGN -> = [169:13]
        |       |       |--IDENT -> vint [169:8]
        |       |       `--NUM_INT -> 0x1234_5678 [169:15]
        |       |--SEMI -> ; [169:26]
        |       |--EXPR -> EXPR [170:13]
        |       |   `--ASSIGN -> = [170:13]
        |       |       |--IDENT -> vint [170:8]
        |       |       `--NUM_INT -> 0b101 [170:15]
        |       |--SEMI -> ; [170:20]
        |       |--EXPR -> EXPR [171:13]
        |       |   `--ASSIGN -> = [171:13]
        |       |       |--IDENT -> vint [171:8]
        |       |       `--NUM_INT -> 0B101 [171:15]
        |       |--SEMI -> ; [171:20]
        |       |--EXPR -> EXPR [172:13]
        |       |   `--ASSIGN -> = [172:13]
        |       |       |--IDENT -> vint [172:8]
        |       |       `--NUM_INT -> 0b1 [172:15]
        |       |--SEMI -> ; [172:18]
        |       |--EXPR -> EXPR [173:13]
        |       |   `--ASSIGN -> = [173:13]
        |       |       |--IDENT -> vint [173:8]
        |       |       `--NUM_INT -> 0b1_0 [173:15]
        |       |--SEMI -> ; [173:20]
        |       |--EXPR -> EXPR [174:13]
        |       |   `--ASSIGN -> = [174:13]
        |       |       |--IDENT -> vint [174:8]
        |       |       `--NUM_INT -> 012345670 [174:15]
        |       |--SEMI -> ; [174:24]
        |       |--EXPR -> EXPR [175:13]
        |       |   `--ASSIGN -> = [175:13]
        |       |       |--IDENT -> vint [175:8]
        |       |       `--NUM_INT -> 01234_5670 [175:15]
        |       |--SEMI -> ; [175:25]
        |       |--EXPR -> EXPR [176:14]
        |       |   `--ASSIGN -> = [176:14]
        |       |       |--IDENT -> vlong [176:8]
        |       |       `--NUM_LONG -> 0L [176:16]
        |       |--SEMI -> ; [176:18]
        |       |--EXPR -> EXPR [177:14]
        |       |   `--ASSIGN -> = [177:14]
        |       |       |--IDENT -> vlong [177:8]
        |       |       `--NUM_LONG -> 1L [177:16]
        |       |--SEMI -> ; [177:18]
        |       |--EXPR -> EXPR [178:14]
        |       |   `--ASSIGN -> = [178:14]
        |       |       |--IDENT -> vlong [178:8]
        |       |       `--NUM_LONG -> 0b1L [178:16]
        |       |--SEMI -> ; [178:20]
        |       |--EXPR -> EXPR [179:14]
        |       |   `--ASSIGN -> = [179:14]
        |       |       |--IDENT -> vlong [179:8]
        |       |       `--NUM_LONG -> 1234567890l [179:16]
        |       |--SEMI -> ; [179:27]
        |       |--EXPR -> EXPR [180:14]
        |       |   `--ASSIGN -> = [180:14]
        |       |       |--IDENT -> vlong [180:8]
        |       |       `--NUM_LONG -> 1234567890L [180:16]
        |       |--SEMI -> ; [180:27]
        |       |--EXPR -> EXPR [181:14]
        |       |   `--ASSIGN -> = [181:14]
        |       |       |--IDENT -> vlong [181:8]
        |       |       `--NUM_LONG -> 0x0l [181:16]
        |       |--SEMI -> ; [181:20]
        |       |--EXPR -> EXPR [182:14]
        |       |   `--ASSIGN -> = [182:14]
        |       |       |--IDENT -> vlong [182:8]
        |       |       `--NUM_LONG -> 0xABCDEFl [182:16]
        |       |--SEMI -> ; [182:25]
        |       |--EXPR -> EXPR [183:14]
        |       |   `--ASSIGN -> = [183:14]
        |       |       |--IDENT -> vlong [183:8]
        |       |       `--NUM_LONG -> 0XABCDEFL [183:16]
        |       |--SEMI -> ; [183:25]
        |       |--EXPR -> EXPR [184:15]
        |       |   `--ASSIGN -> = [184:15]
        |       |       |--IDENT -> vfloat [184:8]
        |       |       `--NUM_FLOAT -> 0f [184:17]
        |       |--SEMI -> ; [184:19]
        |       |--EXPR -> EXPR [185:15]
        |       |   `--ASSIGN -> = [185:15]
        |       |       |--IDENT -> vfloat [185:8]
        |       |       `--NUM_FLOAT -> 0F [185:17]
        |       |--SEMI -> ; [185:19]
        |       |--EXPR -> EXPR [186:15]
        |       |   `--ASSIGN -> = [186:15]
        |       |       |--IDENT -> vfloat [186:8]
        |       |       `--NUM_FLOAT -> 1.1f [186:17]
        |       |--SEMI -> ; [186:21]
        |       |--EXPR -> EXPR [187:15]
        |       |   `--ASSIGN -> = [187:15]
        |       |       |--IDENT -> vfloat [187:8]
        |       |       `--NUM_FLOAT -> 1.10_1F [187:17]
        |       |--SEMI -> ; [187:24]
        |       |--EXPR -> EXPR [188:15]
        |       |   `--ASSIGN -> = [188:15]
        |       |       |--IDENT -> vfloat [188:8]
        |       |       `--NUM_FLOAT -> 0_1.1_1F [188:17]
        |       |--SEMI -> ; [188:25]
        |       |--EXPR -> EXPR [189:15]
        |       |   `--ASSIGN -> = [189:15]
        |       |       |--IDENT -> vfloat [189:8]
        |       |       `--NUM_FLOAT -> 1e0f [189:17]
        |       |--SEMI -> ; [189:21]
        |       |--EXPR -> EXPR [190:15]
        |       |   `--ASSIGN -> = [190:15]
        |       |       |--IDENT -> vfloat [190:8]
        |       |       `--NUM_FLOAT -> 1e0F [190:17]
        |       |--SEMI -> ; [190:21]
        |       |--EXPR -> EXPR [191:15]
        |       |   `--ASSIGN -> = [191:15]
        |       |       |--IDENT -> vfloat [191:8]
        |       |       `--NUM_FLOAT -> 1.0e0F [191:17]
        |       |--SEMI -> ; [191:23]
        |       |--EXPR -> EXPR [192:15]
        |       |   `--ASSIGN -> = [192:15]
        |       |       |--IDENT -> vfloat [192:8]
        |       |       `--NUM_FLOAT -> 0x2__3_34.4___AFP00_00f [192:17]
        |       |--SEMI -> ; [192:40]
        |       |--EXPR -> EXPR [193:16]
        |       |   `--ASSIGN -> = [193:16]
        |       |       |--IDENT -> vdouble [193:8]
        |       |       `--NUM_FLOAT -> 10. [193:18]
        |       |--SEMI -> ; [193:21]
        |       |--EXPR -> EXPR [194:16]
        |       |   `--ASSIGN -> = [194:16]
        |       |       |--IDENT -> vdouble [194:8]
        |       |       `--NUM_FLOAT -> .1 [194:18]
        |       |--SEMI -> ; [194:20]
        |       |--EXPR -> EXPR [195:16]
        |       |   `--ASSIGN -> = [195:16]
        |       |       |--IDENT -> vdouble [195:8]
        |       |       `--NUM_FLOAT -> .1__1_1 [195:18]
        |       |--SEMI -> ; [195:25]
        |       |--EXPR -> EXPR [196:16]
        |       |   `--ASSIGN -> = [196:16]
        |       |       |--IDENT -> vdouble [196:8]
        |       |       `--NUM_FLOAT -> 0.0 [196:18]
        |       |--SEMI -> ; [196:21]
        |       |--EXPR -> EXPR [197:16]
        |       |   `--ASSIGN -> = [197:16]
        |       |       |--IDENT -> vdouble [197:8]
        |       |       `--NUM_FLOAT -> 1000.0 [197:18]
        |       |--SEMI -> ; [197:24]
        |       |--EXPR -> EXPR [198:16]
        |       |   `--ASSIGN -> = [198:16]
        |       |       |--IDENT -> vdouble [198:8]
        |       |       `--NUM_DOUBLE -> .1d [198:18]
        |       |--SEMI -> ; [198:21]
        |       |--EXPR -> EXPR [199:16]
        |       |   `--ASSIGN -> = [199:16]
        |       |       |--IDENT -> vdouble [199:8]
        |       |       `--NUM_DOUBLE -> 1.D [199:18]
        |       |--SEMI -> ; [199:21]
        |       |--EXPR -> EXPR [200:16]
        |       |   `--ASSIGN -> = [200:16]
        |       |       |--IDENT -> vdouble [200:8]
        |       |       `--NUM_DOUBLE -> 0_1.0d [200:18]
        |       |--SEMI -> ; [200:24]
        |       |--EXPR -> EXPR [201:16]
        |       |   `--ASSIGN -> = [201:16]
        |       |       |--IDENT -> vdouble [201:8]
        |       |       `--NUM_DOUBLE -> 0_1.0D [201:18]
        |       |--SEMI -> ; [201:24]
        |       |--EXPR -> EXPR [202:16]
        |       |   `--ASSIGN -> = [202:16]
        |       |       |--IDENT -> vdouble [202:8]
        |       |       `--NUM_FLOAT -> 4e23 [202:18]
        |       |--SEMI -> ; [202:22]
        |       |--EXPR -> EXPR [203:16]
        |       |   `--ASSIGN -> = [203:16]
        |       |       |--IDENT -> vdouble [203:8]
        |       |       `--NUM_FLOAT -> 4E23 [203:18]
        |       |--SEMI -> ; [203:22]
        |       |--EXPR -> EXPR [204:16]
        |       |   `--ASSIGN -> = [204:16]
        |       |       |--IDENT -> vdouble [204:8]
        |       |       `--NUM_FLOAT -> 4E2_3 [204:18]
        |       |--SEMI -> ; [204:23]
        |       |--EXPR -> EXPR [205:16]
        |       |   `--ASSIGN -> = [205:16]
        |       |       |--IDENT -> vdouble [205:8]
        |       |       `--NUM_FLOAT -> 0x0.0000000000001p-1022 [205:18]
        |       |--SEMI -> ; [205:41]
        |       |--EXPR -> EXPR [206:16]
        |       |   `--ASSIGN -> = [206:16]
        |       |       |--IDENT -> vdouble [206:8]
        |       |       `--NUM_FLOAT -> 0x0.0000000000001P-1022 [206:18]
        |       |--SEMI -> ; [206:41]
        |       |--EXPR -> EXPR [207:16]
        |       |   `--ASSIGN -> = [207:16]
        |       |       |--IDENT -> vdouble [207:8]
        |       |       `--NUM_FLOAT -> 0X0.0000000000001p+1022 [207:18]
        |       |--SEMI -> ; [207:41]
        |       |--EXPR -> EXPR [208:16]
        |       |   `--ASSIGN -> = [208:16]
        |       |       |--IDENT -> vdouble [208:8]
        |       |       `--NUM_FLOAT -> 0X0.0000000000001P+1022 [208:18]
        |       |--SEMI -> ; [208:41]
        |       |--EXPR -> EXPR [209:16]
        |       |   `--ASSIGN -> = [209:16]
        |       |       |--IDENT -> vdouble [209:8]
        |       |       `--NUM_FLOAT -> 0x.0P0 [209:18]
        |       |--SEMI -> ; [209:24]
        |       |--EXPR -> EXPR [210:16]
        |       |   `--ASSIGN -> = [210:16]
        |       |       |--IDENT -> vdouble [210:8]
        |       |       `--NUM_FLOAT -> 0X0p+2 [210:18]
        |       |--SEMI -> ; [210:24]
        |       |--EXPR -> EXPR [211:16]
        |       |   `--ASSIGN -> = [211:16]
        |       |       |--IDENT -> vdouble [211:8]
        |       |       `--NUM_FLOAT -> 0X0p+20F [211:18]
        |       |--SEMI -> ; [211:26]
        |       |--EXPR -> EXPR [212:16]
        |       |   `--ASSIGN -> = [212:16]
        |       |       |--IDENT -> vdouble [212:8]
        |       |       `--NUM_DOUBLE -> 0X0p+2D [212:18]
        |       |--SEMI -> ; [212:25]
        |       |--EXPR -> EXPR [213:16]
        |       |   `--ASSIGN -> = [213:16]
        |       |       |--IDENT -> vdouble [213:8]
        |       |       `--NUM_DOUBLE -> 0X0p+2d [213:18]
        |       |--SEMI -> ; [213:25]
        |       |--EXPR -> EXPR [214:16]
        |       |   `--ASSIGN -> = [214:16]
        |       |       |--IDENT -> vdouble [214:8]
        |       |       `--NUM_FLOAT -> 0x1.P-1 [214:18]
        |       |--SEMI -> ; [214:25]
        |       |--EXPR -> EXPR [215:16]
        |       |   `--ASSIGN -> = [215:16]
        |       |       |--IDENT -> vdouble [215:8]
        |       |       `--NUM_FLOAT -> 0x.1___AFp1 [215:18]
        |       |--SEMI -> ; [215:29]
        |       |--EXPR -> EXPR [216:16]
        |       |   `--ASSIGN -> = [216:16]
        |       |       |--IDENT -> vstring [216:8]
        |       |       `--LITERAL_NULL -> null [216:18]
        |       |--SEMI -> ; [216:22]
        |       |--EXPR -> EXPR [217:16]
        |       |   `--ASSIGN -> = [217:16]
        |       |       |--IDENT -> vstring [217:8]
        |       |       `--STRING_LITERAL -> "" [217:18]
        |       |--SEMI -> ; [217:20]
        |       |--EXPR -> EXPR [218:16]
        |       |   `--ASSIGN -> = [218:16]
        |       |       |--IDENT -> vstring [218:8]
        |       |       `--STRING_LITERAL -> "\\" [218:18]
        |       |--SEMI -> ; [218:22]
        |       |--EXPR -> EXPR [221:13]
        |       |   `--ASSIGN -> = [221:13]
        |       |       |--IDENT -> vint [221:8]
        |       |       `--PLUS -> + [221:17]
        |       |           |--NUM_INT -> 1 [221:15]
        |       |           `--NUM_INT -> 1 [221:19]
        |       |--SEMI -> ; [221:20]
        |       |--EXPR -> EXPR [222:13]
        |       |   `--ASSIGN -> = [222:13]
        |       |       |--IDENT -> vint [222:8]
        |       |       `--MINUS -> - [222:17]
        |       |           |--NUM_INT -> 1 [222:15]
        |       |           `--NUM_INT -> 1 [222:19]
        |       |--SEMI -> ; [222:20]
        |       |--EXPR -> EXPR [223:13]
        |       |   `--ASSIGN -> = [223:13]
        |       |       |--IDENT -> vint [223:8]
        |       |       `--STAR -> * [223:17]
        |       |           |--NUM_INT -> 1 [223:15]
        |       |           `--NUM_INT -> 1 [223:19]
        |       |--SEMI -> ; [223:20]
        |       |--EXPR -> EXPR [224:13]
        |       |   `--ASSIGN -> = [224:13]
        |       |       |--IDENT -> vint [224:8]
        |       |       `--DIV -> / [224:17]
        |       |           |--NUM_INT -> 1 [224:15]
        |       |           `--NUM_INT -> 1 [224:19]
        |       |--SEMI -> ; [224:20]
        |       |--EXPR -> EXPR [225:13]
        |       |   `--ASSIGN -> = [225:13]
        |       |       |--IDENT -> vint [225:8]
        |       |       `--MOD -> % [225:17]
        |       |           |--NUM_INT -> 1 [225:15]
        |       |           `--NUM_INT -> 1 [225:19]
        |       |--SEMI -> ; [225:20]
        |       |--EXPR -> EXPR [226:13]
        |       |   `--ASSIGN -> = [226:13]
        |       |       |--IDENT -> vint [226:8]
        |       |       `--BAND -> & [226:17]
        |       |           |--NUM_INT -> 1 [226:15]
        |       |           `--NUM_INT -> 1 [226:19]
        |       |--SEMI -> ; [226:20]
        |       |--EXPR -> EXPR [227:13]
        |       |   `--ASSIGN -> = [227:13]
        |       |       |--IDENT -> vint [227:8]
        |       |       `--BOR -> | [227:17]
        |       |           |--NUM_INT -> 1 [227:15]
        |       |           `--NUM_INT -> 1 [227:19]
        |       |--SEMI -> ; [227:20]
        |       |--EXPR -> EXPR [228:13]
        |       |   `--ASSIGN -> = [228:13]
        |       |       |--IDENT -> vint [228:8]
        |       |       `--BXOR -> ^ [228:17]
        |       |           |--NUM_INT -> 1 [228:15]
        |       |           `--NUM_INT -> 1 [228:19]
        |       |--SEMI -> ; [228:20]
        |       |--EXPR -> EXPR [229:13]
        |       |   `--ASSIGN -> = [229:13]
        |       |       |--IDENT -> vint [229:8]
        |       |       `--BNOT -> ~ [229:15]
        |       |           `--NUM_INT -> 1 [229:16]
        |       |--SEMI -> ; [229:17]
        |       |--EXPR -> EXPR [230:17]
        |       |   `--ASSIGN -> = [230:17]
        |       |       |--IDENT -> vboolean [230:8]
        |       |       `--NOT_EQUAL -> != [230:21]
        |       |           |--NUM_INT -> 1 [230:19]
        |       |           `--NUM_INT -> 0 [230:24]
        |       |--SEMI -> ; [230:25]
        |       |--EXPR -> EXPR [231:17]
        |       |   `--ASSIGN -> = [231:17]
        |       |       |--IDENT -> vboolean [231:8]
        |       |       `--EQUAL -> == [231:21]
        |       |           |--NUM_INT -> 1 [231:19]
        |       |           `--NUM_INT -> 0 [231:24]
        |       |--SEMI -> ; [231:25]
        |       |--EXPR -> EXPR [232:17]
        |       |   `--ASSIGN -> = [232:17]
        |       |       |--IDENT -> vboolean [232:8]
        |       |       `--GT -> > [232:21]
        |       |           |--NUM_INT -> 1 [232:19]
        |       |           `--NUM_INT -> 0 [232:23]
        |       |--SEMI -> ; [232:24]
        |       |--EXPR -> EXPR [233:17]
        |       |   `--ASSIGN -> = [233:17]
        |       |       |--IDENT -> vboolean [233:8]
        |       |       `--GE -> >= [233:21]
        |       |           |--NUM_INT -> 1 [233:19]
        |       |           `--NUM_INT -> 0 [233:24]
        |       |--SEMI -> ; [233:25]
        |       |--EXPR -> EXPR [234:17]
        |       |   `--ASSIGN -> = [234:17]
        |       |       |--IDENT -> vboolean [234:8]
        |       |       `--LT -> < [234:21]
        |       |           |--NUM_INT -> 1 [234:19]
        |       |           `--NUM_INT -> 0 [234:23]
        |       |--SEMI -> ; [234:24]
        |       |--EXPR -> EXPR [235:17]
        |       |   `--ASSIGN -> = [235:17]
        |       |       |--IDENT -> vboolean [235:8]
        |       |       `--LE -> <= [235:21]
        |       |           |--NUM_INT -> 1 [235:19]
        |       |           `--NUM_INT -> 0 [235:24]
        |       |--SEMI -> ; [235:25]
        |       |--EXPR -> EXPR [236:17]
        |       |   `--ASSIGN -> = [236:17]
        |       |       |--IDENT -> vboolean [236:8]
        |       |       `--LAND -> && [236:24]
        |       |           |--LITERAL_TRUE -> true [236:19]
        |       |           `--LITERAL_TRUE -> true [236:27]
        |       |--SEMI -> ; [236:31]
        |       |--EXPR -> EXPR [237:17]
        |       |   `--ASSIGN -> = [237:17]
        |       |       |--IDENT -> vboolean [237:8]
        |       |       `--LOR -> || [237:24]
        |       |           |--LITERAL_TRUE -> true [237:19]
        |       |           `--LITERAL_TRUE -> true [237:27]
        |       |--SEMI -> ; [237:31]
        |       |--EXPR -> EXPR [238:17]
        |       |   `--ASSIGN -> = [238:17]
        |       |       |--IDENT -> vboolean [238:8]
        |       |       `--QUESTION -> ? [238:24]
        |       |           |--LITERAL_TRUE -> true [238:19]
        |       |           |--LITERAL_TRUE -> true [238:26]
        |       |           |--COLON -> : [238:31]
        |       |           `--LITERAL_FALSE -> false [238:33]
        |       |--SEMI -> ; [238:38]
        |       |--EXPR -> EXPR [239:17]
        |       |   `--ASSIGN -> = [239:17]
        |       |       |--IDENT -> vboolean [239:8]
        |       |       `--LNOT -> ! [239:19]
        |       |           `--LITERAL_TRUE -> true [239:20]
        |       |--SEMI -> ; [239:24]
        |       |--EXPR -> EXPR [240:17]
        |       |   `--ASSIGN -> = [240:17]
        |       |       |--IDENT -> vboolean [240:8]
        |       |       `--LITERAL_INSTANCEOF -> instanceof [240:22]
        |       |           |--IDENT -> f9 [240:19]
        |       |           `--TYPE -> TYPE [240:33]
        |       |               `--IDENT -> Object [240:33]
        |       |--SEMI -> ; [240:39]
        |       |--EXPR -> EXPR [241:13]
        |       |   `--ASSIGN -> = [241:13]
        |       |       |--IDENT -> vint [241:8]
        |       |       `--SL -> << [241:17]
        |       |           |--NUM_INT -> 1 [241:15]
        |       |           `--NUM_INT -> 1 [241:20]
        |       |--SEMI -> ; [241:21]
        |       |--EXPR -> EXPR [242:13]
        |       |   `--ASSIGN -> = [242:13]
        |       |       |--IDENT -> vint [242:8]
        |       |       `--SR -> >> [242:17]
        |       |           |--NUM_INT -> 1 [242:15]
        |       |           `--NUM_INT -> 1 [242:20]
        |       |--SEMI -> ; [242:21]
        |       |--EXPR -> EXPR [243:13]
        |       |   `--ASSIGN -> = [243:13]
        |       |       |--IDENT -> vint [243:8]
        |       |       `--BSR -> >>> [243:17]
        |       |           |--NUM_INT -> 1 [243:15]
        |       |           `--NUM_INT -> 1 [243:21]
        |       |--SEMI -> ; [243:22]
        |       |--EXPR -> EXPR [244:13]
        |       |   `--PLUS_ASSIGN -> += [244:13]
        |       |       |--IDENT -> vint [244:8]
        |       |       `--NUM_INT -> 1 [244:16]
        |       |--SEMI -> ; [244:17]
        |       |--EXPR -> EXPR [245:13]
        |       |   `--MINUS_ASSIGN -> -= [245:13]
        |       |       |--IDENT -> vint [245:8]
        |       |       `--NUM_INT -> 1 [245:16]
        |       |--SEMI -> ; [245:17]
        |       |--EXPR -> EXPR [246:13]
        |       |   `--STAR_ASSIGN -> *= [246:13]
        |       |       |--IDENT -> vint [246:8]
        |       |       `--NUM_INT -> 1 [246:16]
        |       |--SEMI -> ; [246:17]
        |       |--EXPR -> EXPR [247:13]
        |       |   `--DIV_ASSIGN -> /= [247:13]
        |       |       |--IDENT -> vint [247:8]
        |       |       `--NUM_INT -> 1 [247:16]
        |       |--SEMI -> ; [247:17]
        |       |--EXPR -> EXPR [248:13]
        |       |   `--MOD_ASSIGN -> %= [248:13]
        |       |       |--IDENT -> vint [248:8]
        |       |       `--NUM_INT -> 1 [248:16]
        |       |--SEMI -> ; [248:17]
        |       |--EXPR -> EXPR [249:13]
        |       |   `--BAND_ASSIGN -> &= [249:13]
        |       |       |--IDENT -> vint [249:8]
        |       |       `--NUM_INT -> 1 [249:16]
        |       |--SEMI -> ; [249:17]
        |       |--EXPR -> EXPR [250:13]
        |       |   `--BOR_ASSIGN -> |= [250:13]
        |       |       |--IDENT -> vint [250:8]
        |       |       `--NUM_INT -> 1 [250:16]
        |       |--SEMI -> ; [250:17]
        |       |--EXPR -> EXPR [251:13]
        |       |   `--BXOR_ASSIGN -> ^= [251:13]
        |       |       |--IDENT -> vint [251:8]
        |       |       `--NUM_INT -> 1 [251:16]
        |       |--SEMI -> ; [251:17]
        |       |--EXPR -> EXPR [252:13]
        |       |   `--SL_ASSIGN -> <<= [252:13]
        |       |       |--IDENT -> vint [252:8]
        |       |       `--NUM_INT -> 1 [252:17]
        |       |--SEMI -> ; [252:18]
        |       |--EXPR -> EXPR [253:13]
        |       |   `--SR_ASSIGN -> >>= [253:13]
        |       |       |--IDENT -> vint [253:8]
        |       |       `--NUM_INT -> 1 [253:17]
        |       |--SEMI -> ; [253:18]
        |       |--EXPR -> EXPR [254:13]
        |       |   `--BSR_ASSIGN -> >>>= [254:13]
        |       |       |--IDENT -> vint [254:8]
        |       |       `--NUM_INT -> 1 [254:18]
        |       |--SEMI -> ; [254:19]
        |       |--EXPR -> EXPR [255:12]
        |       |   `--POST_INC -> ++ [255:12]
        |       |       `--IDENT -> vint [255:8]
        |       |--SEMI -> ; [255:14]
        |       |--EXPR -> EXPR [256:12]
        |       |   `--POST_DEC -> -- [256:12]
        |       |       `--IDENT -> vint [256:8]
        |       |--SEMI -> ; [256:14]
        |       |--EXPR -> EXPR [257:8]
        |       |   `--INC -> ++ [257:8]
        |       |       `--IDENT -> vint [257:10]
        |       |--SEMI -> ; [257:14]
        |       |--EXPR -> EXPR [258:8]
        |       |   `--DEC -> -- [258:8]
        |       |       `--IDENT -> vint [258:10]
        |       |--SEMI -> ; [258:14]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [259:8]
        |       |   |--MODIFIERS -> MODIFIERS [259:8]
        |       |   |--TYPE -> TYPE [259:8]
        |       |   |   |--IDENT -> String [259:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [259:14]
        |       |   |       `--RBRACK -> ] [259:15]
        |       |   |--IDENT -> arrayinit [259:17]
        |       |   `--ASSIGN -> = [259:27]
        |       |       `--ARRAY_INIT -> { [259:29]
        |       |           `--RCURLY -> } [259:30]
        |       |--SEMI -> ; [259:31]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [260:8]
        |       |   |--MODIFIERS -> MODIFIERS [260:8]
        |       |   |--TYPE -> TYPE [260:8]
        |       |   |   |--IDENT -> String [260:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [260:14]
        |       |   |       `--RBRACK -> ] [260:15]
        |       |   |--IDENT -> arrayinit2 [260:17]
        |       |   `--ASSIGN -> = [260:28]
        |       |       `--ARRAY_INIT -> { [260:30]
        |       |           |--EXPR -> EXPR [260:31]
        |       |           |   `--STRING_LITERAL -> "" [260:31]
        |       |           `--RCURLY -> } [260:33]
        |       |--SEMI -> ; [260:34]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [261:8]
        |       |   |--MODIFIERS -> MODIFIERS [261:8]
        |       |   |--TYPE -> TYPE [261:8]
        |       |   |   |--IDENT -> String [261:8]
        |       |   |   `--ARRAY_DECLARATOR -> [ [261:14]
        |       |   |       `--RBRACK -> ] [261:15]
        |       |   |--IDENT -> arrayinit3 [261:17]
        |       |   `--ASSIGN -> = [261:28]
        |       |       `--ARRAY_INIT -> { [261:30]
        |       |           |--EXPR -> EXPR [261:31]
        |       |           |   `--STRING_LITERAL -> "" [261:31]
        |       |           |--COMMA -> , [261:33]
        |       |           |--EXPR -> EXPR [261:35]
        |       |           |   `--STRING_LITERAL -> "" [261:35]
        |       |           |--COMMA -> , [261:37]
        |       |           `--RCURLY -> } [261:38]
        |       |--SEMI -> ; [261:39]
        |       |--EXPR -> EXPR [264:15]
        |       |   `--ASSIGN -> = [264:15]
        |       |       |--IDENT -> varray [264:8]
        |       |       `--LITERAL_NEW -> new [264:17]
        |       |           |--LITERAL_INT -> int [264:21]
        |       |           |--ARRAY_DECLARATOR -> [ [264:24]
        |       |           |   `--RBRACK -> ] [264:25]
        |       |           `--ARRAY_INIT -> { [264:26]
        |       |               `--RCURLY -> } [264:27]
        |       |--SEMI -> ; [264:28]
        |       |--EXPR -> EXPR [265:15]
        |       |   `--ASSIGN -> = [265:15]
        |       |       |--IDENT -> varray [265:8]
        |       |       `--LITERAL_NEW -> new [265:17]
        |       |           |--LITERAL_INT -> int [265:21]
        |       |           |--ARRAY_DECLARATOR -> [ [265:24]
        |       |           |   `--RBRACK -> ] [265:25]
        |       |           `--ARRAY_INIT -> { [265:26]
        |       |               |--EXPR -> EXPR [265:27]
        |       |               |   `--NUM_INT -> 0 [265:27]
        |       |               `--RCURLY -> } [265:28]
        |       |--SEMI -> ; [265:29]
        |       |--EXPR -> EXPR [266:15]
        |       |   `--ASSIGN -> = [266:15]
        |       |       |--IDENT -> varray [266:8]
        |       |       `--LITERAL_NEW -> new [266:17]
        |       |           |--LITERAL_INT -> int [266:21]
        |       |           |--ARRAY_DECLARATOR -> [ [266:24]
        |       |           |   `--RBRACK -> ] [266:25]
        |       |           `--ARRAY_INIT -> { [266:26]
        |       |               |--EXPR -> EXPR [266:27]
        |       |               |   `--NUM_INT -> 0 [266:27]
        |       |               |--COMMA -> , [266:28]
        |       |               |--EXPR -> EXPR [266:30]
        |       |               |   `--NUM_INT -> 1 [266:30]
        |       |               `--RCURLY -> } [266:31]
        |       |--SEMI -> ; [266:32]
        |       |--EXPR -> EXPR [267:15]
        |       |   `--ASSIGN -> = [267:15]
        |       |       |--IDENT -> varray [267:8]
        |       |       `--LITERAL_NEW -> new [267:17]
        |       |           |--LITERAL_INT -> int [267:21]
        |       |           `--ARRAY_DECLARATOR -> [ [267:24]
        |       |               |--EXPR -> EXPR [267:25]
        |       |               |   `--NUM_INT -> 5 [267:25]
        |       |               `--RBRACK -> ] [267:26]
        |       |--SEMI -> ; [267:27]
        |       |--EXPR -> EXPR [268:14]
        |       |   `--ASSIGN -> = [268:14]
        |       |       |--IDENT -> vlist [268:8]
        |       |       `--LITERAL_NEW -> new [268:16]
        |       |           |--IDENT -> ArrayList [268:20]
        |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [268:29]
        |       |           |   |--GENERIC_START -> < [268:29]
        |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [268:30]
        |       |           |   |   `--IDENT -> String [268:30]
        |       |           |   `--GENERIC_END -> > [268:36]
        |       |           |--LPAREN -> ( [268:37]
        |       |           |--ELIST -> ELIST [268:38]
        |       |           `--RPAREN -> ) [268:38]
        |       |--SEMI -> ; [268:39]
        |       |--EXPR -> EXPR [269:13]
        |       |   `--ASSIGN -> = [269:13]
        |       |       |--IDENT -> vmap [269:8]
        |       |       `--LITERAL_NEW -> new [269:15]
        |       |           |--IDENT -> HashMap [269:19]
        |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [269:26]
        |       |           |   |--GENERIC_START -> < [269:26]
        |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:27]
        |       |           |   |   `--IDENT -> String [269:27]
        |       |           |   |--COMMA -> , [269:33]
        |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:35]
        |       |           |   |   |--IDENT -> String [269:35]
        |       |           |   |   `--ARRAY_DECLARATOR -> [ [269:41]
        |       |           |   |       `--RBRACK -> ] [269:42]
        |       |           |   `--GENERIC_END -> > [269:43]
        |       |           |--LPAREN -> ( [269:44]
        |       |           |--ELIST -> ELIST [269:45]
        |       |           `--RPAREN -> ) [269:45]
        |       |--SEMI -> ; [269:46]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [270:8]
        |       |   |--MODIFIERS -> MODIFIERS [270:8]
        |       |   |--TYPE -> TYPE [270:8]
        |       |   |   `--IDENT -> Object [270:8]
        |       |   |--IDENT -> anonymous [270:15]
        |       |   `--ASSIGN -> = [270:25]
        |       |       `--EXPR -> EXPR [270:27]
        |       |           `--LITERAL_NEW -> new [270:27]
        |       |               |--IDENT -> InputRegressionJavaClass1 [270:31]
        |       |               |--LPAREN -> ( [270:56]
        |       |               |--ELIST -> ELIST [270:57]
        |       |               |--RPAREN -> ) [270:57]
        |       |               `--OBJBLOCK -> OBJBLOCK [270:59]
        |       |                   |--LCURLY -> { [270:59]
        |       |                   `--RCURLY -> } [270:60]
        |       |--SEMI -> ; [270:61]
        |       |--EMPTY_STAT -> ; [273:8]
        |       |--EXPR -> EXPR [274:16]
        |       |   `--ASSIGN -> = [274:16]
        |       |       |--DOT -> . [274:12]
        |       |       |   |--LITERAL_THIS -> this [274:8]
        |       |       |   `--IDENT -> f1 [274:13]
        |       |       `--NUM_INT -> 0 [274:18]
        |       |--SEMI -> ; [274:19]
        |       |--LABELED_STAT -> : [277:19]
        |       |   |--IDENT -> test_label1 [277:8]
        |       |   `--SLIST -> { [280:8]
        |       |       `--RCURLY -> } [280:9]
        |       |--LITERAL_IF -> if [281:8]
        |       |   |--LPAREN -> ( [281:11]
        |       |   |--EXPR -> EXPR [281:12]
        |       |   |   `--LITERAL_TRUE -> true [281:12]
        |       |   |--RPAREN -> ) [281:16]
        |       |   `--EMPTY_STAT -> ; [281:18]
        |       |--LITERAL_IF -> if [282:8]
        |       |   |--LPAREN -> ( [282:11]
        |       |   |--EXPR -> EXPR [282:12]
        |       |   |   `--LITERAL_TRUE -> true [282:12]
        |       |   |--RPAREN -> ) [282:16]
        |       |   `--SLIST -> { [282:18]
        |       |       `--RCURLY -> } [282:19]
        |       |--LITERAL_IF -> if [283:8]
        |       |   |--LPAREN -> ( [283:11]
        |       |   |--EXPR -> EXPR [283:12]
        |       |   |   `--LITERAL_TRUE -> true [283:12]
        |       |   |--RPAREN -> ) [283:16]
        |       |   |--SLIST -> { [283:18]
        |       |   |   `--RCURLY -> } [283:19]
        |       |   `--LITERAL_ELSE -> else [283:21]
        |       |       `--EMPTY_STAT -> ; [283:26]
        |       |--LITERAL_IF -> if [284:8]
        |       |   |--LPAREN -> ( [284:11]
        |       |   |--EXPR -> EXPR [284:12]
        |       |   |   `--LITERAL_TRUE -> true [284:12]
        |       |   |--RPAREN -> ) [284:16]
        |       |   |--SLIST -> { [284:18]
        |       |   |   `--RCURLY -> } [284:19]
        |       |   `--LITERAL_ELSE -> else [284:21]
        |       |       `--SLIST -> { [284:26]
        |       |           `--RCURLY -> } [284:27]
        |       |--LITERAL_IF -> if [285:8]
        |       |   |--LPAREN -> ( [285:11]
        |       |   |--EXPR -> EXPR [285:12]
        |       |   |   `--IDENT -> b [285:12]
        |       |   |--RPAREN -> ) [285:13]
        |       |   `--SLIST -> { [285:15]
        |       |       |--LITERAL_FOR -> for [285:17]
        |       |       |   |--LPAREN -> ( [285:21]
        |       |       |   |--FOR_INIT -> FOR_INIT [285:22]
        |       |       |   |--SEMI -> ; [285:22]
        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [285:23]
        |       |       |   |--SEMI -> ; [285:23]
        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [285:24]
        |       |       |   |--RPAREN -> ) [285:24]
        |       |       |   `--EMPTY_STAT -> ; [285:26]
        |       |       `--RCURLY -> } [285:28]
        |       |--LITERAL_IF -> if [286:8]
        |       |   |--LPAREN -> ( [286:11]
        |       |   |--EXPR -> EXPR [286:12]
        |       |   |   `--IDENT -> b [286:12]
        |       |   |--RPAREN -> ) [286:13]
        |       |   `--SLIST -> { [286:15]
        |       |       |--LITERAL_FOR -> for [286:17]
        |       |       |   |--LPAREN -> ( [286:21]
        |       |       |   |--FOR_INIT -> FOR_INIT [286:22]
        |       |       |   |--SEMI -> ; [286:22]
        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [286:23]
        |       |       |   |--SEMI -> ; [286:23]
        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [286:24]
        |       |       |   |--RPAREN -> ) [286:24]
        |       |       |   `--SLIST -> { [286:26]
        |       |       |       `--RCURLY -> } [286:27]
        |       |       `--RCURLY -> } [286:29]
        |       |--LITERAL_FOR -> for [287:8]
        |       |   |--LPAREN -> ( [287:12]
        |       |   |--FOR_INIT -> FOR_INIT [287:13]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [287:13]
        |       |   |       |--MODIFIERS -> MODIFIERS [287:13]
        |       |   |       |--TYPE -> TYPE [287:13]
        |       |   |       |   `--LITERAL_INT -> int [287:13]
        |       |   |       |--IDENT -> i [287:17]
        |       |   |       `--ASSIGN -> = [287:19]
        |       |   |           `--EXPR -> EXPR [287:21]
        |       |   |               `--NUM_INT -> 0 [287:21]
        |       |   |--SEMI -> ; [287:22]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [287:26]
        |       |   |   `--EXPR -> EXPR [287:26]
        |       |   |       `--LT -> < [287:26]
        |       |   |           |--IDENT -> i [287:24]
        |       |   |           `--NUM_INT -> 1 [287:28]
        |       |   |--SEMI -> ; [287:29]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [287:32]
        |       |   |   `--ELIST -> ELIST [287:32]
        |       |   |       `--EXPR -> EXPR [287:32]
        |       |   |           `--POST_INC -> ++ [287:32]
        |       |   |               `--IDENT -> i [287:31]
        |       |   |--RPAREN -> ) [287:34]
        |       |   `--SLIST -> { [287:36]
        |       |       `--RCURLY -> } [287:37]
        |       |--LITERAL_FOR -> for [288:8]
        |       |   |--LPAREN -> ( [288:12]
        |       |   |--FOR_INIT -> FOR_INIT [288:13]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [288:13]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [288:13]
        |       |   |   |   |--TYPE -> TYPE [288:13]
        |       |   |   |   |   `--LITERAL_INT -> int [288:13]
        |       |   |   |   |--IDENT -> i [288:17]
        |       |   |   |   `--ASSIGN -> = [288:19]
        |       |   |   |       `--EXPR -> EXPR [288:21]
        |       |   |   |           `--NUM_INT -> 0 [288:21]
        |       |   |   |--COMMA -> , [288:22]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [288:13]
        |       |   |       |--MODIFIERS -> MODIFIERS [288:13]
        |       |   |       |--TYPE -> TYPE [288:13]
        |       |   |       |   `--LITERAL_INT -> int [288:13]
        |       |   |       |--IDENT -> j [288:24]
        |       |   |       `--ASSIGN -> = [288:26]
        |       |   |           `--EXPR -> EXPR [288:28]
        |       |   |               `--NUM_INT -> 0 [288:28]
        |       |   |--SEMI -> ; [288:29]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [288:33]
        |       |   |   `--EXPR -> EXPR [288:33]
        |       |   |       `--LT -> < [288:33]
        |       |   |           |--IDENT -> i [288:31]
        |       |   |           `--NUM_INT -> 1 [288:35]
        |       |   |--SEMI -> ; [288:36]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [288:39]
        |       |   |   `--ELIST -> ELIST [288:39]
        |       |   |       |--EXPR -> EXPR [288:39]
        |       |   |       |   `--POST_INC -> ++ [288:39]
        |       |   |       |       `--IDENT -> i [288:38]
        |       |   |       |--COMMA -> , [288:41]
        |       |   |       `--EXPR -> EXPR [288:45]
        |       |   |           `--PLUS_ASSIGN -> += [288:45]
        |       |   |               |--IDENT -> j [288:43]
        |       |   |               `--NUM_INT -> 2 [288:48]
        |       |   |--RPAREN -> ) [288:49]
        |       |   `--SLIST -> { [288:51]
        |       |       `--RCURLY -> } [288:52]
        |       |--LITERAL_FOR -> for [289:8]
        |       |   |--LPAREN -> ( [289:12]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [289:13]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [289:13]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [289:13]
        |       |   |   |   |--TYPE -> TYPE [289:13]
        |       |   |   |   |   `--LITERAL_INT -> int [289:13]
        |       |   |   |   `--IDENT -> value [289:17]
        |       |   |   |--COLON -> : [289:22]
        |       |   |   `--EXPR -> EXPR [289:24]
        |       |   |       `--LITERAL_NEW -> new [289:24]
        |       |   |           |--LITERAL_INT -> int [289:28]
        |       |   |           |--ARRAY_DECLARATOR -> [ [289:31]
        |       |   |           |   `--RBRACK -> ] [289:32]
        |       |   |           `--ARRAY_INIT -> { [289:33]
        |       |   |               `--RCURLY -> } [289:34]
        |       |   |--RPAREN -> ) [289:35]
        |       |   `--EMPTY_STAT -> ; [289:37]
        |       |--LITERAL_FOR -> for [290:8]
        |       |   |--LPAREN -> ( [290:12]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [290:13]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [290:13]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [290:13]
        |       |   |   |   |--TYPE -> TYPE [290:13]
        |       |   |   |   |   `--IDENT -> String [290:13]
        |       |   |   |   `--IDENT -> s [290:20]
        |       |   |   |--COLON -> : [290:22]
        |       |   |   `--EXPR -> EXPR [290:24]
        |       |   |       `--LITERAL_NEW -> new [290:24]
        |       |   |           |--IDENT -> String [290:28]
        |       |   |           |--ARRAY_DECLARATOR -> [ [290:34]
        |       |   |           |   `--RBRACK -> ] [290:35]
        |       |   |           `--ARRAY_INIT -> { [290:36]
        |       |   |               `--RCURLY -> } [290:37]
        |       |   |--RPAREN -> ) [290:38]
        |       |   `--EMPTY_STAT -> ; [290:40]
        |       |--LITERAL_FOR -> for [291:8]
        |       |   |--LPAREN -> ( [291:12]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [291:13]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [291:13]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [291:13]
        |       |   |   |   |   `--FINAL -> final [291:13]
        |       |   |   |   |--TYPE -> TYPE [291:19]
        |       |   |   |   |   `--IDENT -> String [291:19]
        |       |   |   |   `--IDENT -> s [291:26]
        |       |   |   |--COLON -> : [291:28]
        |       |   |   `--EXPR -> EXPR [291:30]
        |       |   |       `--LITERAL_NEW -> new [291:30]
        |       |   |           |--IDENT -> String [291:34]
        |       |   |           |--ARRAY_DECLARATOR -> [ [291:40]
        |       |   |           |   `--RBRACK -> ] [291:41]
        |       |   |           `--ARRAY_INIT -> { [291:42]
        |       |   |               `--RCURLY -> } [291:43]
        |       |   |--RPAREN -> ) [291:44]
        |       |   `--EMPTY_STAT -> ; [291:46]
        |       |--LITERAL_IF -> if [292:8]
        |       |   |--LPAREN -> ( [292:11]
        |       |   |--EXPR -> EXPR [292:12]
        |       |   |   `--IDENT -> b [292:12]
        |       |   |--RPAREN -> ) [292:13]
        |       |   `--SLIST -> { [292:15]
        |       |       |--LITERAL_WHILE -> while [292:17]
        |       |       |   |--LPAREN -> ( [292:23]
        |       |       |   |--EXPR -> EXPR [292:24]
        |       |       |   |   `--LITERAL_TRUE -> true [292:24]
        |       |       |   |--RPAREN -> ) [292:28]
        |       |       |   `--EMPTY_STAT -> ; [292:30]
        |       |       `--RCURLY -> } [292:32]
        |       |--LITERAL_IF -> if [293:8]
        |       |   |--LPAREN -> ( [293:11]
        |       |   |--EXPR -> EXPR [293:12]
        |       |   |   `--IDENT -> b [293:12]
        |       |   |--RPAREN -> ) [293:13]
        |       |   `--SLIST -> { [293:15]
        |       |       |--LITERAL_WHILE -> while [293:17]
        |       |       |   |--LPAREN -> ( [293:23]
        |       |       |   |--EXPR -> EXPR [293:24]
        |       |       |   |   `--LITERAL_TRUE -> true [293:24]
        |       |       |   |--RPAREN -> ) [293:28]
        |       |       |   `--SLIST -> { [293:30]
        |       |       |       `--RCURLY -> } [293:31]
        |       |       `--RCURLY -> } [293:33]
        |       |--LITERAL_DO -> do [294:8]
        |       |   |--SLIST -> { [294:11]
        |       |   |   `--RCURLY -> } [294:12]
        |       |   |--DO_WHILE -> while [294:14]
        |       |   |--LPAREN -> ( [294:20]
        |       |   |--EXPR -> EXPR [294:21]
        |       |   |   `--LITERAL_FALSE -> false [294:21]
        |       |   |--RPAREN -> ) [294:26]
        |       |   `--SEMI -> ; [294:27]
        |       |--LITERAL_SYNCHRONIZED -> synchronized [295:8]
        |       |   |--LPAREN -> ( [295:21]
        |       |   |--EXPR -> EXPR [295:22]
        |       |   |   `--IDENT -> f9 [295:22]
        |       |   |--RPAREN -> ) [295:24]
        |       |   `--SLIST -> { [295:26]
        |       |       `--RCURLY -> } [295:27]
        |       |--LITERAL_SWITCH -> switch [297:8]
        |       |   |--LPAREN -> ( [297:15]
        |       |   |--EXPR -> EXPR [297:16]
        |       |   |   `--NUM_INT -> 0 [297:16]
        |       |   |--RPAREN -> ) [297:17]
        |       |   |--LCURLY -> { [297:19]
        |       |   |--CASE_GROUP -> CASE_GROUP [298:12]
        |       |   |   |--LITERAL_CASE -> case [298:12]
        |       |   |   |   |--EXPR -> EXPR [298:17]
        |       |   |   |   |   `--NUM_INT -> 1 [298:17]
        |       |   |   |   `--COLON -> : [298:18]
        |       |   |   |--LITERAL_CASE -> case [299:12]
        |       |   |   |   |--EXPR -> EXPR [299:17]
        |       |   |   |   |   `--NUM_INT -> 0 [299:17]
        |       |   |   |   `--COLON -> : [299:18]
        |       |   |   `--SLIST -> SLIST [299:20]
        |       |   |       `--LITERAL_BREAK -> break [299:20]
        |       |   |           `--SEMI -> ; [299:25]
        |       |   |--CASE_GROUP -> CASE_GROUP [300:12]
        |       |   |   |--LITERAL_DEFAULT -> default [300:12]
        |       |   |   |   `--COLON -> : [300:19]
        |       |   |   `--SLIST -> SLIST [300:21]
        |       |   |       `--LITERAL_BREAK -> break [300:21]
        |       |   |           `--SEMI -> ; [300:26]
        |       |   `--RCURLY -> } [301:8]
        |       |--LITERAL_TRY -> try [303:8]
        |       |   |--SLIST -> { [303:12]
        |       |   |   |--LITERAL_IF -> if [304:12]
        |       |   |   |   |--LPAREN -> ( [304:15]
        |       |   |   |   |--EXPR -> EXPR [304:16]
        |       |   |   |   |   `--IDENT -> b [304:16]
        |       |   |   |   |--RPAREN -> ) [304:17]
        |       |   |   |   `--SLIST -> { [304:19]
        |       |   |   |       |--LITERAL_THROW -> throw [304:21]
        |       |   |   |       |   |--EXPR -> EXPR [304:27]
        |       |   |   |       |   |   `--LITERAL_NEW -> new [304:27]
        |       |   |   |       |   |       |--IDENT -> IOException [304:31]
        |       |   |   |       |   |       |--LPAREN -> ( [304:42]
        |       |   |   |       |   |       |--ELIST -> ELIST [304:43]
        |       |   |   |       |   |       `--RPAREN -> ) [304:43]
        |       |   |   |       |   `--SEMI -> ; [304:44]
        |       |   |   |       `--RCURLY -> } [304:46]
        |       |   |   |--LITERAL_IF -> if [305:12]
        |       |   |   |   |--LPAREN -> ( [305:15]
        |       |   |   |   |--EXPR -> EXPR [305:16]
        |       |   |   |   |   `--IDENT -> b [305:16]
        |       |   |   |   |--RPAREN -> ) [305:17]
        |       |   |   |   `--SLIST -> { [305:19]
        |       |   |   |       |--LITERAL_THROW -> throw [305:21]
        |       |   |   |       |   |--EXPR -> EXPR [305:27]
        |       |   |   |       |   |   `--LITERAL_NEW -> new [305:27]
        |       |   |   |       |   |       |--IDENT -> ArrayIndexOutOfBoundsException [305:31]
        |       |   |   |       |   |       |--LPAREN -> ( [305:61]
        |       |   |   |       |   |       |--ELIST -> ELIST [305:62]
        |       |   |   |       |   |       `--RPAREN -> ) [305:62]
        |       |   |   |       |   `--SEMI -> ; [305:63]
        |       |   |   |       `--RCURLY -> } [305:65]
        |       |   |   |--LITERAL_THROW -> throw [306:12]
        |       |   |   |   |--EXPR -> EXPR [306:18]
        |       |   |   |   |   `--LITERAL_NEW -> new [306:18]
        |       |   |   |   |       |--IDENT -> Exception [306:22]
        |       |   |   |   |       |--LPAREN -> ( [306:31]
        |       |   |   |   |       |--ELIST -> ELIST [306:32]
        |       |   |   |   |       `--RPAREN -> ) [306:32]
        |       |   |   |   `--SEMI -> ; [306:33]
        |       |   |   `--RCURLY -> } [307:8]
        |       |   |--LITERAL_CATCH -> catch [307:10]
        |       |   |   |--LPAREN -> ( [307:16]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [307:17]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [307:17]
        |       |   |   |   |--TYPE -> TYPE [307:17]
        |       |   |   |   |   |--IDENT -> IOException [307:17]
        |       |   |   |   |   |--BOR -> | [307:29]
        |       |   |   |   |   `--IDENT -> ArrayIndexOutOfBoundsException [307:31]
        |       |   |   |   `--IDENT -> e [307:62]
        |       |   |   |--RPAREN -> ) [307:63]
        |       |   |   `--SLIST -> { [307:65]
        |       |   |       `--RCURLY -> } [308:8]
        |       |   |--LITERAL_CATCH -> catch [308:10]
        |       |   |   |--LPAREN -> ( [308:16]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [308:17]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [308:17]
        |       |   |   |   |--TYPE -> TYPE [308:17]
        |       |   |   |   |   `--IDENT -> Exception [308:17]
        |       |   |   |   `--IDENT -> e [308:27]
        |       |   |   |--RPAREN -> ) [308:28]
        |       |   |   `--SLIST -> { [308:30]
        |       |   |       `--RCURLY -> } [309:8]
        |       |   `--LITERAL_FINALLY -> finally [309:10]
        |       |       `--SLIST -> { [309:18]
        |       |           `--RCURLY -> } [309:19]
        |       |--LITERAL_TRY -> try [310:8]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [310:12]
        |       |   |   |--LPAREN -> ( [310:12]
        |       |   |   |--RESOURCES -> RESOURCES [310:13]
        |       |   |   |   `--RESOURCE -> RESOURCE [310:13]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [310:13]
        |       |   |   |       |--TYPE -> TYPE [310:13]
        |       |   |   |       |   `--IDENT -> BufferedReader [310:13]
        |       |   |   |       |--IDENT -> br [310:28]
        |       |   |   |       `--ASSIGN -> = [310:31]
        |       |   |   |           `--EXPR -> EXPR [310:33]
        |       |   |   |               `--LITERAL_NEW -> new [310:33]
        |       |   |   |                   |--IDENT -> BufferedReader [310:37]
        |       |   |   |                   |--LPAREN -> ( [310:51]
        |       |   |   |                   |--ELIST -> ELIST [310:52]
        |       |   |   |                   |   `--EXPR -> EXPR [310:52]
        |       |   |   |                   |       `--LITERAL_NEW -> new [310:52]
        |       |   |   |                   |           |--IDENT -> InputStreamReader [310:56]
        |       |   |   |                   |           |--LPAREN -> ( [310:73]
        |       |   |   |                   |           |--ELIST -> ELIST [310:74]
        |       |   |   |                   |           |   |--EXPR -> EXPR [310:74]
        |       |   |   |                   |           |   |   `--LITERAL_NULL -> null [310:74]
        |       |   |   |                   |           |   |--COMMA -> , [310:78]
        |       |   |   |                   |           |   `--EXPR -> EXPR [310:80]
        |       |   |   |                   |           |       `--STRING_LITERAL -> "utf-8" [310:80]
        |       |   |   |                   |           `--RPAREN -> ) [310:87]
        |       |   |   |                   `--RPAREN -> ) [310:88]
        |       |   |   `--RPAREN -> ) [310:89]
        |       |   `--SLIST -> { [310:91]
        |       |       `--RCURLY -> } [310:92]
        |       |--LITERAL_TRY -> try [311:8]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [311:12]
        |       |   |   |--LPAREN -> ( [311:12]
        |       |   |   |--RESOURCES -> RESOURCES [311:13]
        |       |   |   |   |--RESOURCE -> RESOURCE [311:13]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [311:13]
        |       |   |   |   |   |--TYPE -> TYPE [311:13]
        |       |   |   |   |   |   `--IDENT -> BufferedReader [311:13]
        |       |   |   |   |   |--IDENT -> br1 [311:28]
        |       |   |   |   |   `--ASSIGN -> = [311:32]
        |       |   |   |   |       `--EXPR -> EXPR [311:34]
        |       |   |   |   |           `--LITERAL_NEW -> new [311:34]
        |       |   |   |   |               |--IDENT -> BufferedReader [311:38]
        |       |   |   |   |               |--LPAREN -> ( [311:52]
        |       |   |   |   |               |--ELIST -> ELIST [311:53]
        |       |   |   |   |               |   `--EXPR -> EXPR [311:53]
        |       |   |   |   |               |       `--LITERAL_NEW -> new [311:53]
        |       |   |   |   |               |           |--IDENT -> InputStreamReader [311:57]
        |       |   |   |   |               |           |--LPAREN -> ( [311:74]
        |       |   |   |   |               |           |--ELIST -> ELIST [311:75]
        |       |   |   |   |               |           |   |--EXPR -> EXPR [311:75]
        |       |   |   |   |               |           |   |   `--LITERAL_NULL -> null [311:75]
        |       |   |   |   |               |           |   |--COMMA -> , [311:79]
        |       |   |   |   |               |           |   `--EXPR -> EXPR [311:81]
        |       |   |   |   |               |           |       `--STRING_LITERAL -> "utf-8" [311:81]
        |       |   |   |   |               |           `--RPAREN -> ) [311:88]
        |       |   |   |   |               `--RPAREN -> ) [311:89]
        |       |   |   |   |--SEMI -> ; [311:90]
        |       |   |   |   `--RESOURCE -> RESOURCE [312:16]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [312:16]
        |       |   |   |       |--TYPE -> TYPE [312:16]
        |       |   |   |       |   `--IDENT -> BufferedReader [312:16]
        |       |   |   |       |--IDENT -> br2 [312:31]
        |       |   |   |       `--ASSIGN -> = [312:35]
        |       |   |   |           `--EXPR -> EXPR [312:37]
        |       |   |   |               `--LITERAL_NEW -> new [312:37]
        |       |   |   |                   |--IDENT -> BufferedReader [312:41]
        |       |   |   |                   |--LPAREN -> ( [312:55]
        |       |   |   |                   |--ELIST -> ELIST [312:56]
        |       |   |   |                   |   `--EXPR -> EXPR [312:56]
        |       |   |   |                   |       `--LITERAL_NEW -> new [312:56]
        |       |   |   |                   |           |--IDENT -> InputStreamReader [312:60]
        |       |   |   |                   |           |--LPAREN -> ( [312:77]
        |       |   |   |                   |           |--ELIST -> ELIST [312:78]
        |       |   |   |                   |           |   |--EXPR -> EXPR [312:78]
        |       |   |   |                   |           |   |   `--LITERAL_NULL -> null [312:78]
        |       |   |   |                   |           |   |--COMMA -> , [312:82]
        |       |   |   |                   |           |   `--EXPR -> EXPR [312:84]
        |       |   |   |                   |           |       `--STRING_LITERAL -> "utf-8" [312:84]
        |       |   |   |                   |           `--RPAREN -> ) [312:91]
        |       |   |   |                   `--RPAREN -> ) [312:92]
        |       |   |   |--SEMI -> ; [312:93]
        |       |   |   `--RPAREN -> ) [312:94]
        |       |   `--SLIST -> { [312:96]
        |       |       `--RCURLY -> } [312:97]
        |       |--EXPR -> EXPR [315:14]
        |       |   `--ASSIGN -> = [315:14]
        |       |       |--IDENT -> test4 [315:8]
        |       |       `--DOT -> . [315:41]
        |       |           |--IDENT -> InputRegressionJavaClass1 [315:16]
        |       |           `--LITERAL_CLASS -> class [315:42]
        |       |--SEMI -> ; [315:47]
        |       |--EXPR -> EXPR [316:14]
        |       |   `--ASSIGN -> = [316:14]
        |       |       |--IDENT -> test4 [316:8]
        |       |       `--DOT -> . [316:22]
        |       |           |--IDENT -> List [316:16]
        |       |           |--ARRAY_DECLARATOR -> [ [316:20]
        |       |           |   `--RBRACK -> ] [316:21]
        |       |           `--LITERAL_CLASS -> class [316:23]
        |       |--SEMI -> ; [316:28]
        |       |--EXPR -> EXPR [317:14]
        |       |   `--ASSIGN -> = [317:14]
        |       |       |--IDENT -> test4 [317:8]
        |       |       `--DOT -> . [317:25]
        |       |           |--LITERAL_BOOLEAN -> boolean [317:16]
        |       |           |--ARRAY_DECLARATOR -> [ [317:23]
        |       |           |   `--RBRACK -> ] [317:24]
        |       |           `--LITERAL_CLASS -> class [317:26]
        |       |--SEMI -> ; [317:31]
        |       |--EXPR -> EXPR [318:18]
        |       |   `--ASSIGN -> = [318:18]
        |       |       |--INDEX_OP -> [ [318:14]
        |       |       |   |--IDENT -> varray [318:8]
        |       |       |   |--EXPR -> EXPR [318:15]
        |       |       |   |   `--NUM_INT -> 0 [318:15]
        |       |       |   `--RBRACK -> ] [318:16]
        |       |       `--NUM_INT -> 0 [318:20]
        |       |--SEMI -> ; [318:21]
        |       |--LITERAL_FOR -> for [319:8]
        |       |   |--LPAREN -> ( [319:12]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [319:13]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [319:13]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [319:13]
        |       |   |   |   |--TYPE -> TYPE [319:13]
        |       |   |   |   |   |--IDENT -> String [319:13]
        |       |   |   |   |   `--ARRAY_DECLARATOR -> [ [319:19]
        |       |   |   |   |       `--RBRACK -> ] [319:20]
        |       |   |   |   `--IDENT -> s [319:22]
        |       |   |   |--COLON -> : [319:24]
        |       |   |   `--EXPR -> EXPR [319:26]
        |       |   |       `--LITERAL_NEW -> new [319:26]
        |       |   |           |--IDENT -> String [319:30]
        |       |   |           |--ARRAY_DECLARATOR -> [ [319:36]
        |       |   |           |   `--RBRACK -> ] [319:37]
        |       |   |           |--ARRAY_DECLARATOR -> [ [319:38]
        |       |   |           |   `--RBRACK -> ] [319:39]
        |       |   |           `--ARRAY_INIT -> { [319:40]
        |       |   |               |--ARRAY_INIT -> { [319:41]
        |       |   |               |   `--RCURLY -> } [319:42]
        |       |   |               `--RCURLY -> } [319:43]
        |       |   |--RPAREN -> ) [319:44]
        |       |   `--EMPTY_STAT -> ; [319:46]
        |       |--LITERAL_FOR -> for [320:8]
        |       |   |--LPAREN -> ( [320:12]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [320:16]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [320:16]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [320:16]
        |       |   |   |   |--TYPE -> TYPE [320:16]
        |       |   |   |   |   `--DOT -> . [320:16]
        |       |   |   |   |       |--IDENT -> Map [320:13]
        |       |   |   |   |       |--IDENT -> Entry [320:17]
        |       |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [320:22]
        |       |   |   |   |           |--GENERIC_START -> < [320:22]
        |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [320:23]
        |       |   |   |   |           |   `--IDENT -> String [320:23]
        |       |   |   |   |           |--COMMA -> , [320:29]
        |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [320:31]
        |       |   |   |   |           |   |--IDENT -> String [320:31]
        |       |   |   |   |           |   `--ARRAY_DECLARATOR -> [ [320:37]
        |       |   |   |   |           |       `--RBRACK -> ] [320:38]
        |       |   |   |   |           `--GENERIC_END -> > [320:39]
        |       |   |   |   `--IDENT -> e [320:41]
        |       |   |   |--COLON -> : [320:43]
        |       |   |   `--EXPR -> EXPR [320:58]
        |       |   |       `--METHOD_CALL -> ( [320:58]
        |       |   |           |--DOT -> . [320:49]
        |       |   |           |   |--IDENT -> vmap [320:45]
        |       |   |           |   `--IDENT -> entrySet [320:50]
        |       |   |           |--ELIST -> ELIST [320:59]
        |       |   |           `--RPAREN -> ) [320:59]
        |       |   |--RPAREN -> ) [320:60]
        |       |   `--SLIST -> { [320:62]
        |       |       `--RCURLY -> } [320:64]
        |       |--LITERAL_FOR -> for [323:8]
        |       |   |--LPAREN -> ( [323:12]
        |       |   |--FOR_INIT -> FOR_INIT [323:13]
        |       |   |--SEMI -> ; [323:13]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [323:14]
        |       |   |--SEMI -> ; [323:14]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [323:15]
        |       |   |--RPAREN -> ) [323:15]
        |       |   `--SLIST -> { [323:17]
        |       |       |--LITERAL_BREAK -> break [323:18]
        |       |       |   `--SEMI -> ; [323:23]
        |       |       `--RCURLY -> } [323:24]
        |       |--LABELED_STAT -> : [324:19]
        |       |   |--IDENT -> test_label2 [324:8]
        |       |   `--LITERAL_FOR -> for [325:8]
        |       |       |--LPAREN -> ( [325:12]
        |       |       |--FOR_INIT -> FOR_INIT [325:13]
        |       |       |--SEMI -> ; [325:13]
        |       |       |--FOR_CONDITION -> FOR_CONDITION [325:14]
        |       |       |--SEMI -> ; [325:14]
        |       |       |--FOR_ITERATOR -> FOR_ITERATOR [325:15]
        |       |       |--RPAREN -> ) [325:15]
        |       |       `--SLIST -> { [325:17]
        |       |           |--LITERAL_BREAK -> break [325:18]
        |       |           |   |--IDENT -> test_label2 [325:24]
        |       |           |   `--SEMI -> ; [325:35]
        |       |           `--RCURLY -> } [325:36]
        |       |--LITERAL_IF -> if [326:8]
        |       |   |--LPAREN -> ( [326:11]
        |       |   |--EXPR -> EXPR [326:12]
        |       |   |   `--IDENT -> b [326:12]
        |       |   |--RPAREN -> ) [326:13]
        |       |   `--SLIST -> { [326:15]
        |       |       |--LITERAL_FOR -> for [326:17]
        |       |       |   |--LPAREN -> ( [326:21]
        |       |       |   |--FOR_INIT -> FOR_INIT [326:22]
        |       |       |   |--SEMI -> ; [326:22]
        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [326:23]
        |       |       |   |--SEMI -> ; [326:23]
        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [326:24]
        |       |       |   |--RPAREN -> ) [326:24]
        |       |       |   `--SLIST -> { [326:26]
        |       |       |       |--LITERAL_CONTINUE -> continue [326:27]
        |       |       |       |   `--SEMI -> ; [326:35]
        |       |       |       `--RCURLY -> } [326:36]
        |       |       `--RCURLY -> } [326:38]
        |       |--LITERAL_IF -> if [327:8]
        |       |   |--LPAREN -> ( [327:11]
        |       |   |--EXPR -> EXPR [327:12]
        |       |   |   `--IDENT -> b [327:12]
        |       |   |--RPAREN -> ) [327:13]
        |       |   `--SLIST -> { [327:15]
        |       |       |--LABELED_STAT -> : [327:28]
        |       |       |   |--IDENT -> test_label3 [327:17]
        |       |       |   `--LITERAL_FOR -> for [327:30]
        |       |       |       |--LPAREN -> ( [327:34]
        |       |       |       |--FOR_INIT -> FOR_INIT [327:35]
        |       |       |       |--SEMI -> ; [327:35]
        |       |       |       |--FOR_CONDITION -> FOR_CONDITION [327:36]
        |       |       |       |--SEMI -> ; [327:36]
        |       |       |       |--FOR_ITERATOR -> FOR_ITERATOR [327:37]
        |       |       |       |--RPAREN -> ) [327:37]
        |       |       |       `--SLIST -> { [327:39]
        |       |       |           |--LITERAL_CONTINUE -> continue [327:40]
        |       |       |           |   |--IDENT -> test_label3 [327:49]
        |       |       |           |   `--SEMI -> ; [327:60]
        |       |       |           `--RCURLY -> } [327:61]
        |       |       `--RCURLY -> } [327:63]
        |       |--LITERAL_IF -> if [328:8]
        |       |   |--LPAREN -> ( [328:11]
        |       |   |--EXPR -> EXPR [328:12]
        |       |   |   `--LITERAL_FALSE -> false [328:12]
        |       |   |--RPAREN -> ) [328:17]
        |       |   `--LITERAL_RETURN -> return [328:19]
        |       |       `--SEMI -> ; [328:25]
        |       |--LITERAL_IF -> if [329:8]
        |       |   |--LPAREN -> ( [329:11]
        |       |   |--EXPR -> EXPR [329:12]
        |       |   |   `--LITERAL_FALSE -> false [329:12]
        |       |   |--RPAREN -> ) [329:17]
        |       |   `--LITERAL_THROW -> throw [329:19]
        |       |       |--EXPR -> EXPR [329:25]
        |       |       |   `--LITERAL_NEW -> new [329:25]
        |       |       |       |--IDENT -> Exception [329:29]
        |       |       |       |--LPAREN -> ( [329:38]
        |       |       |       |--ELIST -> ELIST [329:39]
        |       |       |       `--RPAREN -> ) [329:39]
        |       |       `--SEMI -> ; [329:40]
        |       |--LITERAL_ASSERT -> assert [330:8]
        |       |   |--EXPR -> EXPR [330:14]
        |       |   |   |--LPAREN -> ( [330:14]
        |       |   |   |--LITERAL_FALSE -> false [330:15]
        |       |   |   `--RPAREN -> ) [330:20]
        |       |   `--SEMI -> ; [330:21]
        |       |--LITERAL_ASSERT -> assert [331:8]
        |       |   |--EXPR -> EXPR [331:15]
        |       |   |   `--LITERAL_TRUE -> true [331:15]
        |       |   |--COLON -> : [331:20]
        |       |   |--EXPR -> EXPR [331:22]
        |       |   |   `--STRING_LITERAL -> "false" [331:22]
        |       |   `--SEMI -> ; [331:29]
        |       |--EXPR -> EXPR [332:11]
        |       |   `--ASSIGN -> = [332:11]
        |       |       |--IDENT -> f9 [332:8]
        |       |       `--TYPECAST -> ( [332:13]
        |       |           |--TYPE -> TYPE [332:14]
        |       |           |   `--IDENT -> Object [332:14]
        |       |           |--RPAREN -> ) [332:20]
        |       |           `--IDENT -> f9 [332:22]
        |       |--SEMI -> ; [332:24]
        |       |--EXPR -> EXPR [333:17]
        |       |   `--METHOD_CALL -> ( [333:17]
        |       |       |--DOT -> . [333:10]
        |       |       |   |--IDENT -> f9 [333:8]
        |       |       |   `--IDENT -> equals [333:11]
        |       |       |--ELIST -> ELIST [333:18]
        |       |       |   `--EXPR -> EXPR [333:18]
        |       |       |       |--LPAREN -> ( [333:18]
        |       |       |       |--LPAREN -> ( [333:19]
        |       |       |       |--ASSIGN -> = [333:28]
        |       |       |       |   |--IDENT -> vstring [333:20]
        |       |       |       |   `--STRING_LITERAL -> "" [333:30]
        |       |       |       |--RPAREN -> ) [333:32]
        |       |       |       `--RPAREN -> ) [333:33]
        |       |       `--RPAREN -> ) [333:34]
        |       |--SEMI -> ; [333:35]
        |       |--LITERAL_FOR -> for [334:8]
        |       |   |--LPAREN -> ( [334:12]
        |       |   |--FOR_INIT -> FOR_INIT [334:13]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [334:13]
        |       |   |       |--MODIFIERS -> MODIFIERS [334:13]
        |       |   |       |--TYPE -> TYPE [334:13]
        |       |   |       |   `--LITERAL_INT -> int [334:13]
        |       |   |       |--IDENT -> i [334:17]
        |       |   |       `--ASSIGN -> = [334:19]
        |       |   |           `--EXPR -> EXPR [334:21]
        |       |   |               `--NUM_INT -> 0 [334:21]
        |       |   |--SEMI -> ; [334:22]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [334:24]
        |       |   |   `--EXPR -> EXPR [334:24]
        |       |   |       |--LPAREN -> ( [334:24]
        |       |   |       |--LT -> < [334:29]
        |       |   |       |   |--LPAREN -> ( [334:25]
        |       |   |       |   |--IDENT -> i [334:26]
        |       |   |       |   |--RPAREN -> ) [334:27]
        |       |   |       |   |--LPAREN -> ( [334:31]
        |       |   |       |   |--PLUS -> + [334:33]
        |       |   |       |   |   |--NUM_INT -> 6 [334:32]
        |       |   |       |   |   `--NUM_INT -> 6 [334:34]
        |       |   |       |   `--RPAREN -> ) [334:35]
        |       |   |       `--RPAREN -> ) [334:36]
        |       |   |--SEMI -> ; [334:37]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [334:40]
        |       |   |   `--ELIST -> ELIST [334:40]
        |       |   |       `--EXPR -> EXPR [334:40]
        |       |   |           `--POST_INC -> ++ [334:40]
        |       |   |               `--IDENT -> i [334:39]
        |       |   |--RPAREN -> ) [334:42]
        |       |   `--EMPTY_STAT -> ; [334:44]
        |       |--LITERAL_IF -> if [335:8]
        |       |   |--LPAREN -> ( [335:11]
        |       |   |--EXPR -> EXPR [335:12]
        |       |   |   |--LPAREN -> ( [335:12]
        |       |   |   |--BAND -> & [335:15]
        |       |   |   |   |--IDENT -> b [335:13]
        |       |   |   |   `--IDENT -> b [335:17]
        |       |   |   `--RPAREN -> ) [335:18]
        |       |   |--RPAREN -> ) [335:19]
        |       |   `--SLIST -> { [335:21]
        |       |       `--RCURLY -> } [335:22]
        |       |--EXPR -> EXPR [338:13]
        |       |   `--ASSIGN -> = [338:13]
        |       |       |--IDENT -> vint [338:8]
        |       |       `--QUESTION -> ? [338:24]
        |       |           |--IDENT -> vboolean [338:15]
        |       |           |--LPAREN -> ( [338:26]
        |       |           |--ASSIGN -> = [338:32]
        |       |           |   |--IDENT -> vint [338:27]
        |       |           |   `--NUM_INT -> 1 [338:34]
        |       |           |--RPAREN -> ) [338:35]
        |       |           |--COLON -> : [338:37]
        |       |           |--LPAREN -> ( [338:39]
        |       |           |--ASSIGN -> = [338:45]
        |       |           |   |--IDENT -> vint [338:40]
        |       |           |   `--NUM_INT -> 0 [338:47]
        |       |           `--RPAREN -> ) [338:48]
        |       |--SEMI -> ; [338:49]
        |       |--EXPR -> EXPR [339:21]
        |       |   `--ASSIGN -> = [339:21]
        |       |       |--INDEX_OP -> [ [339:14]
        |       |       |   |--IDENT -> varray [339:8]
        |       |       |   |--EXPR -> EXPR [339:15]
        |       |       |   |   `--IDENT -> vint [339:15]
        |       |       |   `--RBRACK -> ] [339:19]
        |       |       `--METHOD_CALL -> ( [339:39]
        |       |           |--DOT -> . [339:30]
        |       |           |   |--IDENT -> Integer [339:23]
        |       |           |   `--IDENT -> parseInt [339:31]
        |       |           |--ELIST -> ELIST [339:40]
        |       |           |   `--EXPR -> EXPR [339:40]
        |       |           |       `--STRING_LITERAL -> "0" [339:40]
        |       |           `--RPAREN -> ) [339:43]
        |       |--SEMI -> ; [339:44]
        |       `--RCURLY -> } [340:4]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [342:4]
        |   |--MODIFIERS -> MODIFIERS [342:4]
        |   |   `--LITERAL_PUBLIC -> public [342:4]
        |   |--AT -> @ [342:11]
        |   |--LITERAL_INTERFACE -> interface [342:12]
        |   |--IDENT -> innerAnnotation [342:22]
        |   `--OBJBLOCK -> OBJBLOCK [342:38]
        |       |--LCURLY -> { [342:38]
        |       `--RCURLY -> } [342:39]
        `--RCURLY -> } [343:0]
