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