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]
|--CLASS_DEF -> CLASS_DEF [3:1]
|   |--MODIFIERS -> MODIFIERS [3:1]
|   |   `--LITERAL_PUBLIC -> public [3:1]
|   |--LITERAL_CLASS -> class [3:8]
|   |--IDENT -> InputAntlr4AstRegressionKeywordsAndOperators [3:14]
|   `--OBJBLOCK -> OBJBLOCK [3:59]
|       |--LCURLY -> { [3:59]
|       |--VARIABLE_DEF -> VARIABLE_DEF [5:5]
|       |   |--MODIFIERS -> MODIFIERS [5:5]
|       |   |   `--LITERAL_PRIVATE -> private [5:5]
|       |   |--TYPE -> TYPE [5:13]
|       |   |   `--LITERAL_INT -> int [5:13]
|       |   |--IDENT -> mVar1 [5:17]
|       |   |--ASSIGN -> = [5:22]
|       |   |   `--EXPR -> EXPR [5:23]
|       |   |       `--NUM_INT -> 1 [5:23]
|       |   `--SEMI -> ; [5:24]
|       |--VARIABLE_DEF -> VARIABLE_DEF [7:5]
|       |   |--MODIFIERS -> MODIFIERS [7:5]
|       |   |   `--LITERAL_PRIVATE -> private [7:5]
|       |   |--TYPE -> TYPE [7:13]
|       |   |   `--LITERAL_INT -> int [7:13]
|       |   |--IDENT -> mVar2 [7:17]
|       |   |--ASSIGN -> = [7:23]
|       |   |   `--EXPR -> EXPR [7:24]
|       |   |       `--NUM_INT -> 1 [7:24]
|       |   `--SEMI -> ; [7:25]
|       |--VARIABLE_DEF -> VARIABLE_DEF [9:5]
|       |   |--MODIFIERS -> MODIFIERS [9:5]
|       |   |   `--LITERAL_PRIVATE -> private [9:5]
|       |   |--TYPE -> TYPE [9:13]
|       |   |   `--LITERAL_INT -> int [9:13]
|       |   |--IDENT -> mVar3 [9:17]
|       |   |--ASSIGN -> = [9:23]
|       |   |   `--EXPR -> EXPR [9:25]
|       |   |       `--NUM_INT -> 1 [9:25]
|       |   `--SEMI -> ; [9:26]
|       |--METHOD_DEF -> METHOD_DEF [12:5]
|       |   |--MODIFIERS -> MODIFIERS [12:5]
|       |   |--TYPE -> TYPE [12:5]
|       |   |   `--LITERAL_VOID -> void [12:5]
|       |   |--IDENT -> method1 [12:10]
|       |   |--LPAREN -> ( [12:17]
|       |   |--PARAMETERS -> PARAMETERS [12:18]
|       |   |--RPAREN -> ) [12:18]
|       |   `--SLIST -> { [13:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [14:9]
|       |       |   |--MODIFIERS -> MODIFIERS [14:9]
|       |       |   |   `--FINAL -> final [14:9]
|       |       |   |--TYPE -> TYPE [14:15]
|       |       |   |   `--LITERAL_INT -> int [14:15]
|       |       |   |--IDENT -> a [14:19]
|       |       |   `--ASSIGN -> = [14:21]
|       |       |       `--EXPR -> EXPR [14:23]
|       |       |           `--NUM_INT -> 1 [14:23]
|       |       |--SEMI -> ; [14:24]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [15:9]
|       |       |   |--MODIFIERS -> MODIFIERS [15:9]
|       |       |   |--TYPE -> TYPE [15:9]
|       |       |   |   `--LITERAL_INT -> int [15:9]
|       |       |   |--IDENT -> b [15:13]
|       |       |   `--ASSIGN -> = [15:14]
|       |       |       `--EXPR -> EXPR [15:16]
|       |       |           `--NUM_INT -> 1 [15:16]
|       |       |--SEMI -> ; [15:17]
|       |       |--EXPR -> EXPR [16:10]
|       |       |   `--ASSIGN -> = [16:10]
|       |       |       |--IDENT -> b [16:9]
|       |       |       `--NUM_INT -> 1 [16:11]
|       |       |--SEMI -> ; [16:12]
|       |       |--EXPR -> EXPR [17:10]
|       |       |   `--PLUS_ASSIGN -> += [17:10]
|       |       |       |--IDENT -> b [17:9]
|       |       |       `--NUM_INT -> 1 [17:12]
|       |       |--SEMI -> ; [17:13]
|       |       |--EXPR -> EXPR [18:11]
|       |       |   `--MINUS_ASSIGN -> -= [18:11]
|       |       |       |--IDENT -> b [18:9]
|       |       |       `--PLUS -> + [18:17]
|       |       |           |--UNARY_MINUS -> - [18:13]
|       |       |           |   `--NUM_INT -> 1 [18:15]
|       |       |           |--LPAREN -> ( [18:19]
|       |       |           |--UNARY_PLUS -> + [18:20]
|       |       |           |   `--IDENT -> b [18:22]
|       |       |           `--RPAREN -> ) [18:23]
|       |       |--SEMI -> ; [18:24]
|       |       |--EXPR -> EXPR [19:11]
|       |       |   `--ASSIGN -> = [19:11]
|       |       |       |--IDENT -> b [19:9]
|       |       |       `--PLUS -> + [19:18]
|       |       |           |--POST_INC -> ++ [19:15]
|       |       |           |   `--IDENT -> b [19:13]
|       |       |           `--POST_DEC -> -- [19:22]
|       |       |               `--IDENT -> b [19:20]
|       |       |--SEMI -> ; [19:24]
|       |       |--EXPR -> EXPR [20:11]
|       |       |   `--ASSIGN -> = [20:11]
|       |       |       |--IDENT -> b [20:9]
|       |       |       `--MINUS -> - [20:18]
|       |       |           |--INC -> ++ [20:13]
|       |       |           |   `--IDENT -> b [20:16]
|       |       |           `--DEC -> -- [20:20]
|       |       |               `--IDENT -> b [20:23]
|       |       |--SEMI -> ; [20:24]
|       |       `--RCURLY -> } [21:5]
|       |--METHOD_DEF -> METHOD_DEF [24:5]
|       |   |--MODIFIERS -> MODIFIERS [24:5]
|       |   |--TYPE -> TYPE [24:5]
|       |   |   `--LITERAL_VOID -> void [24:5]
|       |   |--IDENT -> method2 [24:10]
|       |   |--LPAREN -> ( [24:17]
|       |   |--PARAMETERS -> PARAMETERS [24:18]
|       |   |--RPAREN -> ) [24:18]
|       |   `--SLIST -> { [25:5]
|       |       |--LITERAL_SYNCHRONIZED -> synchronized [26:9]
|       |       |   |--LPAREN -> ( [26:21]
|       |       |   |--EXPR -> EXPR [26:22]
|       |       |   |   `--LITERAL_THIS -> this [26:22]
|       |       |   |--RPAREN -> ) [26:26]
|       |       |   `--SLIST -> { [26:28]
|       |       |       `--RCURLY -> } [27:9]
|       |       |--LITERAL_TRY -> try [28:9]
|       |       |   |--SLIST -> { [28:12]
|       |       |   |   `--RCURLY -> } [29:9]
|       |       |   `--LITERAL_CATCH -> catch [30:9]
|       |       |       |--LPAREN -> ( [30:14]
|       |       |       |--PARAMETER_DEF -> PARAMETER_DEF [30:15]
|       |       |       |   |--MODIFIERS -> MODIFIERS [30:15]
|       |       |       |   |--TYPE -> TYPE [30:15]
|       |       |       |   |   `--IDENT -> RuntimeException [30:15]
|       |       |       |   `--IDENT -> e [30:32]
|       |       |       |--RPAREN -> ) [30:33]
|       |       |       `--SLIST -> { [30:34]
|       |       |           `--RCURLY -> } [31:9]
|       |       `--RCURLY -> } [32:5]
|       |--VARIABLE_DEF -> VARIABLE_DEF [40:5]
|       |   |--MODIFIERS -> MODIFIERS [40:5]
|       |   |   `--LITERAL_PRIVATE -> private [40:5]
|       |   |--TYPE -> TYPE [40:13]
|       |   |   `--LITERAL_INT -> int [40:13]
|       |   |--IDENT -> mVar4 [40:17]
|       |   |--ASSIGN -> = [40:23]
|       |   |   `--EXPR -> EXPR [40:25]
|       |   |       `--NUM_INT -> 1 [40:25]
|       |   `--SEMI -> ; [40:26]
|       |--METHOD_DEF -> METHOD_DEF [44:5]
|       |   |--MODIFIERS -> MODIFIERS [44:5]
|       |   |   `--LITERAL_PRIVATE -> private [44:5]
|       |   |--TYPE -> TYPE [44:13]
|       |   |   `--LITERAL_VOID -> void [44:13]
|       |   |--IDENT -> fastExit [44:18]
|       |   |--LPAREN -> ( [44:26]
|       |   |--PARAMETERS -> PARAMETERS [44:27]
|       |   |--RPAREN -> ) [44:27]
|       |   `--SLIST -> { [45:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [46:9]
|       |       |   |--MODIFIERS -> MODIFIERS [46:9]
|       |       |   |--TYPE -> TYPE [46:9]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [46:9]
|       |       |   |--IDENT -> complicatedStuffNeeded [46:17]
|       |       |   `--ASSIGN -> = [46:40]
|       |       |       `--EXPR -> EXPR [46:42]
|       |       |           `--LITERAL_TRUE -> true [46:42]
|       |       |--SEMI -> ; [46:46]
|       |       |--LITERAL_IF -> if [47:9]
|       |       |   |--LPAREN -> ( [47:11]
|       |       |   |--EXPR -> EXPR [47:13]
|       |       |   |   `--LNOT -> ! [47:13]
|       |       |   |       `--IDENT -> complicatedStuffNeeded [47:14]
|       |       |   |--RPAREN -> ) [47:37]
|       |       |   |--SLIST -> { [48:9]
|       |       |   |   |--LITERAL_RETURN -> return [49:13]
|       |       |   |   |   `--SEMI -> ; [49:19]
|       |       |   |   `--RCURLY -> } [50:9]
|       |       |   `--LITERAL_ELSE -> else [51:9]
|       |       |       `--SLIST -> { [52:9]
|       |       |           `--RCURLY -> } [54:9]
|       |       `--RCURLY -> } [55:5]
|       |--METHOD_DEF -> METHOD_DEF [61:5]
|       |   |--MODIFIERS -> MODIFIERS [61:5]
|       |   |   `--LITERAL_PRIVATE -> private [61:5]
|       |   |--TYPE -> TYPE [61:13]
|       |   |   `--LITERAL_INT -> int [61:13]
|       |   |--IDENT -> nonVoid [61:17]
|       |   |--LPAREN -> ( [61:24]
|       |   |--PARAMETERS -> PARAMETERS [61:25]
|       |   |--RPAREN -> ) [61:25]
|       |   `--SLIST -> { [62:5]
|       |       |--LITERAL_IF -> if [63:9]
|       |       |   |--LPAREN -> ( [63:12]
|       |       |   |--EXPR -> EXPR [63:14]
|       |       |   |   `--LITERAL_TRUE -> true [63:14]
|       |       |   |--RPAREN -> ) [63:19]
|       |       |   |--SLIST -> { [64:9]
|       |       |   |   |--LITERAL_RETURN -> return [65:13]
|       |       |   |   |   |--EXPR -> EXPR [65:19]
|       |       |   |   |   |   |--LPAREN -> ( [65:19]
|       |       |   |   |   |   |--NUM_INT -> 2 [65:20]
|       |       |   |   |   |   `--RPAREN -> ) [65:21]
|       |       |   |   |   `--SEMI -> ; [65:22]
|       |       |   |   `--RCURLY -> } [66:9]
|       |       |   `--LITERAL_ELSE -> else [67:9]
|       |       |       `--SLIST -> { [68:9]
|       |       |           |--LITERAL_RETURN -> return [69:13]
|       |       |           |   |--EXPR -> EXPR [69:20]
|       |       |           |   |   `--NUM_INT -> 2 [69:20]
|       |       |           |   `--SEMI -> ; [69:21]
|       |       |           `--RCURLY -> } [70:9]
|       |       `--RCURLY -> } [71:5]
|       |--METHOD_DEF -> METHOD_DEF [74:5]
|       |   |--MODIFIERS -> MODIFIERS [74:5]
|       |   |   `--LITERAL_PRIVATE -> private [74:5]
|       |   |--TYPE -> TYPE [74:13]
|       |   |   `--LITERAL_VOID -> void [74:13]
|       |   |--IDENT -> testCasts [74:18]
|       |   |--LPAREN -> ( [74:27]
|       |   |--PARAMETERS -> PARAMETERS [74:28]
|       |   |--RPAREN -> ) [74:28]
|       |   `--SLIST -> { [75:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [76:9]
|       |       |   |--MODIFIERS -> MODIFIERS [76:9]
|       |       |   |--TYPE -> TYPE [76:9]
|       |       |   |   `--IDENT -> Object [76:9]
|       |       |   |--IDENT -> o [76:16]
|       |       |   `--ASSIGN -> = [76:18]
|       |       |       `--EXPR -> EXPR [76:20]
|       |       |           `--TYPECAST -> ( [76:20]
|       |       |               |--TYPE -> TYPE [76:21]
|       |       |               |   `--IDENT -> Object [76:21]
|       |       |               |--RPAREN -> ) [76:27]
|       |       |               `--LITERAL_NEW -> new [76:29]
|       |       |                   |--IDENT -> Object [76:33]
|       |       |                   |--LPAREN -> ( [76:39]
|       |       |                   |--ELIST -> ELIST [76:40]
|       |       |                   `--RPAREN -> ) [76:40]
|       |       |--SEMI -> ; [76:41]
|       |       |--EXPR -> EXPR [77:11]
|       |       |   `--ASSIGN -> = [77:11]
|       |       |       |--IDENT -> o [77:9]
|       |       |       `--TYPECAST -> ( [77:13]
|       |       |           |--TYPE -> TYPE [77:14]
|       |       |           |   `--IDENT -> Object [77:14]
|       |       |           |--RPAREN -> ) [77:20]
|       |       |           `--IDENT -> o [77:21]
|       |       |--SEMI -> ; [77:22]
|       |       |--EXPR -> EXPR [78:11]
|       |       |   `--ASSIGN -> = [78:11]
|       |       |       |--IDENT -> o [78:9]
|       |       |       `--TYPECAST -> ( [78:13]
|       |       |           |--TYPE -> TYPE [78:15]
|       |       |           |   `--IDENT -> Object [78:15]
|       |       |           |--RPAREN -> ) [78:22]
|       |       |           `--IDENT -> o [78:24]
|       |       |--SEMI -> ; [78:25]
|       |       |--EXPR -> EXPR [79:11]
|       |       |   `--ASSIGN -> = [79:11]
|       |       |       |--IDENT -> o [79:9]
|       |       |       `--TYPECAST -> ( [79:13]
|       |       |           |--TYPE -> TYPE [79:14]
|       |       |           |   `--IDENT -> Object [79:14]
|       |       |           |--RPAREN -> ) [79:20]
|       |       |           `--IDENT -> o [80:13]
|       |       |--SEMI -> ; [80:14]
|       |       `--RCURLY -> } [81:5]
|       |--METHOD_DEF -> METHOD_DEF [84:5]
|       |   |--MODIFIERS -> MODIFIERS [84:5]
|       |   |   `--LITERAL_PRIVATE -> private [84:5]
|       |   |--TYPE -> TYPE [84:13]
|       |   |   `--LITERAL_VOID -> void [84:13]
|       |   |--IDENT -> testQuestions [84:18]
|       |   |--LPAREN -> ( [84:31]
|       |   |--PARAMETERS -> PARAMETERS [84:32]
|       |   |--RPAREN -> ) [84:32]
|       |   `--SLIST -> { [85:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [86:9]
|       |       |   |--MODIFIERS -> MODIFIERS [86:9]
|       |       |   |--TYPE -> TYPE [86:9]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [86:9]
|       |       |   |--IDENT -> b [86:17]
|       |       |   `--ASSIGN -> = [86:19]
|       |       |       `--EXPR -> EXPR [86:29]
|       |       |           `--QUESTION -> ? [86:29]
|       |       |               |--LPAREN -> ( [86:21]
|       |       |               |--EQUAL -> == [86:24]
|       |       |               |   |--NUM_INT -> 1 [86:22]
|       |       |               |   `--NUM_INT -> 2 [86:27]
|       |       |               |--RPAREN -> ) [86:28]
|       |       |               |--LITERAL_TRUE -> true [86:30]
|       |       |               |--COLON -> : [86:34]
|       |       |               `--LITERAL_FALSE -> false [86:35]
|       |       |--SEMI -> ; [86:40]
|       |       |--EXPR -> EXPR [87:11]
|       |       |   `--ASSIGN -> = [87:11]
|       |       |       |--IDENT -> b [87:9]
|       |       |       `--QUESTION -> ? [87:20]
|       |       |           |--LPAREN -> ( [87:13]
|       |       |           |--EQUAL -> == [87:15]
|       |       |           |   |--NUM_INT -> 1 [87:14]
|       |       |           |   `--NUM_INT -> 2 [87:17]
|       |       |           |--RPAREN -> ) [87:18]
|       |       |           |--LITERAL_FALSE -> false [87:22]
|       |       |           |--COLON -> : [87:28]
|       |       |           `--LITERAL_TRUE -> true [87:30]
|       |       |--SEMI -> ; [87:34]
|       |       `--RCURLY -> } [88:5]
|       |--METHOD_DEF -> METHOD_DEF [91:5]
|       |   |--MODIFIERS -> MODIFIERS [91:5]
|       |   |   `--LITERAL_PRIVATE -> private [91:5]
|       |   |--TYPE -> TYPE [91:13]
|       |   |   `--LITERAL_VOID -> void [91:13]
|       |   |--IDENT -> starTest [91:18]
|       |   |--LPAREN -> ( [91:26]
|       |   |--PARAMETERS -> PARAMETERS [91:27]
|       |   |--RPAREN -> ) [91:27]
|       |   `--SLIST -> { [92:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [93:9]
|       |       |   |--MODIFIERS -> MODIFIERS [93:9]
|       |       |   |--TYPE -> TYPE [93:9]
|       |       |   |   `--LITERAL_INT -> int [93:9]
|       |       |   |--IDENT -> x [93:13]
|       |       |   `--ASSIGN -> = [93:15]
|       |       |       `--EXPR -> EXPR [93:21]
|       |       |           `--STAR -> * [93:21]
|       |       |               |--STAR -> * [93:19]
|       |       |               |   |--NUM_INT -> 2 [93:17]
|       |       |               |   `--NUM_INT -> 3 [93:20]
|       |       |               `--NUM_INT -> 4 [93:23]
|       |       |--SEMI -> ; [93:24]
|       |       `--RCURLY -> } [94:5]
|       |--METHOD_DEF -> METHOD_DEF [97:5]
|       |   |--MODIFIERS -> MODIFIERS [97:5]
|       |   |   `--LITERAL_PRIVATE -> private [97:5]
|       |   |--TYPE -> TYPE [97:13]
|       |   |   `--LITERAL_VOID -> void [97:13]
|       |   |--IDENT -> boolTest [97:18]
|       |   |--LPAREN -> ( [97:26]
|       |   |--PARAMETERS -> PARAMETERS [97:27]
|       |   |--RPAREN -> ) [97:27]
|       |   `--SLIST -> { [98:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [99:9]
|       |       |   |--MODIFIERS -> MODIFIERS [99:9]
|       |       |   |--TYPE -> TYPE [99:9]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [99:9]
|       |       |   |--IDENT -> a [99:17]
|       |       |   `--ASSIGN -> = [99:19]
|       |       |       `--EXPR -> EXPR [99:21]
|       |       |           `--LITERAL_TRUE -> true [99:21]
|       |       |--SEMI -> ; [99:25]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [100:9]
|       |       |   |--MODIFIERS -> MODIFIERS [100:9]
|       |       |   |--TYPE -> TYPE [100:9]
|       |       |   |   `--LITERAL_BOOLEAN -> boolean [100:9]
|       |       |   |--IDENT -> x [100:17]
|       |       |   `--ASSIGN -> = [100:19]
|       |       |       `--EXPR -> EXPR [100:21]
|       |       |           `--LNOT -> ! [100:21]
|       |       |               `--IDENT -> a [100:23]
|       |       |--SEMI -> ; [100:24]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [101:9]
|       |       |   |--MODIFIERS -> MODIFIERS [101:9]
|       |       |   |--TYPE -> TYPE [101:9]
|       |       |   |   `--LITERAL_INT -> int [101:9]
|       |       |   |--IDENT -> z [101:13]
|       |       |   `--ASSIGN -> = [101:15]
|       |       |       `--EXPR -> EXPR [101:20]
|       |       |           `--PLUS -> + [101:20]
|       |       |               |--BNOT -> ~ [101:17]
|       |       |               |   `--NUM_INT -> 1 [101:18]
|       |       |               `--BNOT -> ~ [101:22]
|       |       |                   `--NUM_INT -> 2 [101:24]
|       |       |--SEMI -> ; [101:25]
|       |       `--RCURLY -> } [102:5]
|       |--METHOD_DEF -> METHOD_DEF [105:5]
|       |   |--MODIFIERS -> MODIFIERS [105:5]
|       |   |   `--LITERAL_PRIVATE -> private [105:5]
|       |   |--TYPE -> TYPE [105:13]
|       |   |   `--LITERAL_VOID -> void [105:13]
|       |   |--IDENT -> divTest [105:18]
|       |   |--LPAREN -> ( [105:25]
|       |   |--PARAMETERS -> PARAMETERS [105:26]
|       |   |--RPAREN -> ) [105:26]
|       |   `--SLIST -> { [106:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [107:9]
|       |       |   |--MODIFIERS -> MODIFIERS [107:9]
|       |       |   |--TYPE -> TYPE [107:9]
|       |       |   |   `--LITERAL_INT -> int [107:9]
|       |       |   |--IDENT -> a [107:13]
|       |       |   `--ASSIGN -> = [107:15]
|       |       |       `--EXPR -> EXPR [107:19]
|       |       |           `--MOD -> % [107:19]
|       |       |               |--NUM_INT -> 4 [107:17]
|       |       |               `--NUM_INT -> 2 [107:21]
|       |       |--SEMI -> ; [107:22]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [108:9]
|       |       |   |--MODIFIERS -> MODIFIERS [108:9]
|       |       |   |--TYPE -> TYPE [108:9]
|       |       |   |   `--LITERAL_INT -> int [108:9]
|       |       |   |--IDENT -> b [108:13]
|       |       |   `--ASSIGN -> = [108:15]
|       |       |       `--EXPR -> EXPR [108:18]
|       |       |           `--MOD -> % [108:18]
|       |       |               |--NUM_INT -> 4 [108:17]
|       |       |               `--NUM_INT -> 2 [108:20]
|       |       |--SEMI -> ; [108:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [109:9]
|       |       |   |--MODIFIERS -> MODIFIERS [109:9]
|       |       |   |--TYPE -> TYPE [109:9]
|       |       |   |   `--LITERAL_INT -> int [109:9]
|       |       |   |--IDENT -> c [109:13]
|       |       |   `--ASSIGN -> = [109:15]
|       |       |       `--EXPR -> EXPR [109:19]
|       |       |           `--MOD -> % [109:19]
|       |       |               |--NUM_INT -> 4 [109:17]
|       |       |               `--NUM_INT -> 2 [109:20]
|       |       |--SEMI -> ; [109:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [110:9]
|       |       |   |--MODIFIERS -> MODIFIERS [110:9]
|       |       |   |--TYPE -> TYPE [110:9]
|       |       |   |   `--LITERAL_INT -> int [110:9]
|       |       |   |--IDENT -> d [110:13]
|       |       |   `--ASSIGN -> = [110:15]
|       |       |       `--EXPR -> EXPR [110:18]
|       |       |           `--MOD -> % [110:18]
|       |       |               |--NUM_INT -> 4 [110:17]
|       |       |               `--NUM_INT -> 2 [110:19]
|       |       |--SEMI -> ; [110:20]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [111:9]
|       |       |   |--MODIFIERS -> MODIFIERS [111:9]
|       |       |   |--TYPE -> TYPE [111:9]
|       |       |   |   `--LITERAL_INT -> int [111:9]
|       |       |   |--IDENT -> e [111:13]
|       |       |   `--ASSIGN -> = [111:15]
|       |       |       `--EXPR -> EXPR [111:19]
|       |       |           `--DIV -> / [111:19]
|       |       |               |--NUM_INT -> 4 [111:17]
|       |       |               `--NUM_INT -> 2 [111:21]
|       |       |--SEMI -> ; [111:22]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [112:9]
|       |       |   |--MODIFIERS -> MODIFIERS [112:9]
|       |       |   |--TYPE -> TYPE [112:9]
|       |       |   |   `--LITERAL_INT -> int [112:9]
|       |       |   |--IDENT -> f [112:13]
|       |       |   `--ASSIGN -> = [112:15]
|       |       |       `--EXPR -> EXPR [112:18]
|       |       |           `--DIV -> / [112:18]
|       |       |               |--NUM_INT -> 4 [112:17]
|       |       |               `--NUM_INT -> 2 [112:20]
|       |       |--SEMI -> ; [112:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [113:9]
|       |       |   |--MODIFIERS -> MODIFIERS [113:9]
|       |       |   |--TYPE -> TYPE [113:9]
|       |       |   |   `--LITERAL_INT -> int [113:9]
|       |       |   |--IDENT -> g [113:13]
|       |       |   `--ASSIGN -> = [113:15]
|       |       |       `--EXPR -> EXPR [113:19]
|       |       |           `--DIV -> / [113:19]
|       |       |               |--NUM_INT -> 4 [113:17]
|       |       |               `--NUM_INT -> 2 [113:20]
|       |       |--SEMI -> ; [113:21]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [114:9]
|       |       |   |--MODIFIERS -> MODIFIERS [114:9]
|       |       |   |--TYPE -> TYPE [114:9]
|       |       |   |   `--LITERAL_INT -> int [114:9]
|       |       |   |--IDENT -> h [114:13]
|       |       |   `--ASSIGN -> = [114:15]
|       |       |       `--EXPR -> EXPR [114:18]
|       |       |           `--DIV -> / [114:18]
|       |       |               |--NUM_INT -> 4 [114:17]
|       |       |               `--NUM_INT -> 2 [114:19]
|       |       |--SEMI -> ; [114:20]
|       |       `--RCURLY -> } [115:5]
|       |--METHOD_DEF -> METHOD_DEF [118:5]
|       |   |--MODIFIERS -> MODIFIERS [118:5]
|       |   |   `--LITERAL_PRIVATE -> private [118:5]
|       |   |--TYPE -> TYPE [118:23]
|       |   |   `--DOT -> . [118:23]
|       |   |       |--DOT -> . [118:18]
|       |   |       |   |--IDENT -> java [118:13]
|       |   |       |   `--IDENT -> lang [118:19]
|       |   |       `--IDENT -> String [118:26]
|       |   |--IDENT -> dotTest [118:33]
|       |   |--LPAREN -> ( [118:40]
|       |   |--PARAMETERS -> PARAMETERS [118:41]
|       |   |--RPAREN -> ) [118:41]
|       |   `--SLIST -> { [119:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [120:9]
|       |       |   |--MODIFIERS -> MODIFIERS [120:9]
|       |       |   |--TYPE -> TYPE [120:9]
|       |       |   |   `--IDENT -> Object [120:9]
|       |       |   |--IDENT -> o [120:16]
|       |       |   `--ASSIGN -> = [120:18]
|       |       |       `--EXPR -> EXPR [120:20]
|       |       |           `--LITERAL_NEW -> new [120:20]
|       |       |               |--DOT -> . [120:33]
|       |       |               |   |--DOT -> . [120:28]
|       |       |               |   |   |--IDENT -> java [120:24]
|       |       |               |   |   `--IDENT -> lang [120:29]
|       |       |               |   `--IDENT -> Object [120:34]
|       |       |               |--LPAREN -> ( [120:40]
|       |       |               |--ELIST -> ELIST [120:41]
|       |       |               `--RPAREN -> ) [120:41]
|       |       |--SEMI -> ; [120:42]
|       |       |--EXPR -> EXPR [122:21]
|       |       |   `--METHOD_CALL -> ( [122:21]
|       |       |       |--DOT -> . [121:10]
|       |       |       |   |--IDENT -> o [121:9]
|       |       |       |   `--IDENT -> toString [122:13]
|       |       |       |--ELIST -> ELIST [122:22]
|       |       |       `--RPAREN -> ) [122:22]
|       |       |--SEMI -> ; [122:23]
|       |       |--EXPR -> EXPR [124:22]
|       |       |   `--METHOD_CALL -> ( [124:22]
|       |       |       |--DOT -> . [124:13]
|       |       |       |   |--IDENT -> o [123:9]
|       |       |       |   `--IDENT -> toString [124:14]
|       |       |       |--ELIST -> ELIST [124:23]
|       |       |       `--RPAREN -> ) [124:23]
|       |       |--SEMI -> ; [124:24]
|       |       |--EXPR -> EXPR [125:21]
|       |       |   `--METHOD_CALL -> ( [125:21]
|       |       |       |--DOT -> . [125:11]
|       |       |       |   |--IDENT -> o [125:9]
|       |       |       |   `--IDENT -> toString [125:13]
|       |       |       |--ELIST -> ELIST [125:22]
|       |       |       `--RPAREN -> ) [125:22]
|       |       |--SEMI -> ; [125:23]
|       |       |--LITERAL_RETURN -> return [126:9]
|       |       |   |--EXPR -> EXPR [126:26]
|       |       |   |   `--METHOD_CALL -> ( [126:26]
|       |       |   |       |--DOT -> . [126:17]
|       |       |   |       |   |--IDENT -> o [126:16]
|       |       |   |       |   `--IDENT -> toString [126:18]
|       |       |   |       |--ELIST -> ELIST [126:27]
|       |       |   |       `--RPAREN -> ) [126:27]
|       |       |   `--SEMI -> ; [126:28]
|       |       `--RCURLY -> } [127:5]
|       |--METHOD_DEF -> METHOD_DEF [130:5]
|       |   |--MODIFIERS -> MODIFIERS [130:5]
|       |   |   `--LITERAL_PUBLIC -> public [130:5]
|       |   |--TYPE -> TYPE [130:12]
|       |   |   `--LITERAL_VOID -> void [130:12]
|       |   |--IDENT -> assertTest [130:17]
|       |   |--LPAREN -> ( [130:27]
|       |   |--PARAMETERS -> PARAMETERS [130:28]
|       |   |--RPAREN -> ) [130:28]
|       |   `--SLIST -> { [131:5]
|       |       |--LITERAL_ASSERT -> assert [133:9]
|       |       |   |--EXPR -> EXPR [133:16]
|       |       |   |   `--LITERAL_TRUE -> true [133:16]
|       |       |   `--SEMI -> ; [133:20]
|       |       |--LITERAL_ASSERT -> assert [136:9]
|       |       |   |--EXPR -> EXPR [136:16]
|       |       |   |   `--LITERAL_TRUE -> true [136:16]
|       |       |   |--COLON -> : [136:21]
|       |       |   |--EXPR -> EXPR [136:23]
|       |       |   |   `--STRING_LITERAL -> "Whups" [136:23]
|       |       |   `--SEMI -> ; [136:30]
|       |       |--LITERAL_ASSERT -> assert [139:9]
|       |       |   |--EXPR -> EXPR [139:34]
|       |       |   |   `--QUESTION -> ? [139:34]
|       |       |   |       |--METHOD_CALL -> ( [139:27]
|       |       |   |       |   |--DOT -> . [139:20]
|       |       |   |       |   |   |--STRING_LITERAL -> "OK" [139:16]
|       |       |   |       |   |   `--IDENT -> equals [139:21]
|       |       |   |       |   |--ELIST -> ELIST [139:28]
|       |       |   |       |   |   `--EXPR -> EXPR [139:28]
|       |       |   |       |   |       `--LITERAL_NULL -> null [139:28]
|       |       |   |       |   `--RPAREN -> ) [139:32]
|       |       |   |       |--LITERAL_FALSE -> false [139:36]
|       |       |   |       |--COLON -> : [139:42]
|       |       |   |       `--LITERAL_TRUE -> true [139:44]
|       |       |   |--COLON -> : [139:49]
|       |       |   |--EXPR -> EXPR [139:51]
|       |       |   |   `--STRING_LITERAL -> "Whups" [139:51]
|       |       |   `--SEMI -> ; [139:58]
|       |       |--LITERAL_ASSERT -> assert [142:9]
|       |       |   |--EXPR -> EXPR [142:15]
|       |       |   |   |--LPAREN -> ( [142:15]
|       |       |   |   |--LITERAL_TRUE -> true [142:16]
|       |       |   |   `--RPAREN -> ) [142:20]
|       |       |   `--SEMI -> ; [142:21]
|       |       |--LITERAL_ASSERT -> assert [145:9]
|       |       |   |--EXPR -> EXPR [145:16]
|       |       |   |   `--LITERAL_TRUE -> true [145:16]
|       |       |   |--COLON -> : [145:20]
|       |       |   |--EXPR -> EXPR [145:21]
|       |       |   |   `--STRING_LITERAL -> "Whups" [145:21]
|       |       |   `--SEMI -> ; [145:28]
|       |       `--RCURLY -> } [146:5]
|       |--METHOD_DEF -> METHOD_DEF [149:5]
|       |   |--MODIFIERS -> MODIFIERS [149:5]
|       |   |--TYPE -> TYPE [149:5]
|       |   |   `--LITERAL_VOID -> void [149:5]
|       |   |--IDENT -> donBradman [149:10]
|       |   |--LPAREN -> ( [149:20]
|       |   |--PARAMETERS -> PARAMETERS [149:21]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [149:21]
|       |   |       |--MODIFIERS -> MODIFIERS [149:21]
|       |   |       |--TYPE -> TYPE [149:21]
|       |   |       |   `--IDENT -> Runnable [149:21]
|       |   |       `--IDENT -> aRun [149:30]
|       |   |--RPAREN -> ) [149:34]
|       |   `--SLIST -> { [150:5]
|       |       |--EXPR -> EXPR [151:19]
|       |       |   `--METHOD_CALL -> ( [151:19]
|       |       |       |--IDENT -> donBradman [151:9]
|       |       |       |--ELIST -> ELIST [151:20]
|       |       |       |   `--EXPR -> EXPR [151:20]
|       |       |       |       `--LITERAL_NEW -> new [151:20]
|       |       |       |           |--IDENT -> Runnable [151:24]
|       |       |       |           |--LPAREN -> ( [151:32]
|       |       |       |           |--ELIST -> ELIST [151:33]
|       |       |       |           |--RPAREN -> ) [151:33]
|       |       |       |           `--OBJBLOCK -> OBJBLOCK [151:35]
|       |       |       |               |--LCURLY -> { [151:35]
|       |       |       |               |--METHOD_DEF -> METHOD_DEF [152:13]
|       |       |       |               |   |--MODIFIERS -> MODIFIERS [152:13]
|       |       |       |               |   |   `--LITERAL_PUBLIC -> public [152:13]
|       |       |       |               |   |--TYPE -> TYPE [152:20]
|       |       |       |               |   |   `--LITERAL_VOID -> void [152:20]
|       |       |       |               |   |--IDENT -> run [152:25]
|       |       |       |               |   |--LPAREN -> ( [152:28]
|       |       |       |               |   |--PARAMETERS -> PARAMETERS [152:29]
|       |       |       |               |   |--RPAREN -> ) [152:29]
|       |       |       |               |   `--SLIST -> { [152:31]
|       |       |       |               |       `--RCURLY -> } [153:13]
|       |       |       |               `--RCURLY -> } [154:9]
|       |       |       `--RPAREN -> ) [154:10]
|       |       |--SEMI -> ; [154:11]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [156:9]
|       |       |   |--MODIFIERS -> MODIFIERS [156:9]
|       |       |   |   `--FINAL -> final [156:9]
|       |       |   |--TYPE -> TYPE [156:15]
|       |       |   |   `--IDENT -> Runnable [156:15]
|       |       |   |--IDENT -> r [156:24]
|       |       |   `--ASSIGN -> = [156:26]
|       |       |       `--EXPR -> EXPR [156:28]
|       |       |           `--LITERAL_NEW -> new [156:28]
|       |       |               |--IDENT -> Runnable [156:32]
|       |       |               |--LPAREN -> ( [156:40]
|       |       |               |--ELIST -> ELIST [156:41]
|       |       |               |--RPAREN -> ) [156:41]
|       |       |               `--OBJBLOCK -> OBJBLOCK [156:43]
|       |       |                   |--LCURLY -> { [156:43]
|       |       |                   |--METHOD_DEF -> METHOD_DEF [157:13]
|       |       |                   |   |--MODIFIERS -> MODIFIERS [157:13]
|       |       |                   |   |   `--LITERAL_PUBLIC -> public [157:13]
|       |       |                   |   |--TYPE -> TYPE [157:20]
|       |       |                   |   |   `--LITERAL_VOID -> void [157:20]
|       |       |                   |   |--IDENT -> run [157:25]
|       |       |                   |   |--LPAREN -> ( [157:28]
|       |       |                   |   |--PARAMETERS -> PARAMETERS [157:29]
|       |       |                   |   |--RPAREN -> ) [157:29]
|       |       |                   |   `--SLIST -> { [157:31]
|       |       |                   |       `--RCURLY -> } [158:13]
|       |       |                   `--RCURLY -> } [159:9]
|       |       |--SEMI -> ; [159:10]
|       |       `--RCURLY -> } [160:5]
|       |--METHOD_DEF -> METHOD_DEF [163:5]
|       |   |--MODIFIERS -> MODIFIERS [163:5]
|       |   |--TYPE -> TYPE [163:5]
|       |   |   `--LITERAL_VOID -> void [163:5]
|       |   |--IDENT -> rfe521323 [163:10]
|       |   |--LPAREN -> ( [163:19]
|       |   |--PARAMETERS -> PARAMETERS [163:20]
|       |   |--RPAREN -> ) [163:20]
|       |   `--SLIST -> { [164:5]
|       |       |--EXPR -> EXPR [165:16]
|       |       |   `--METHOD_CALL -> ( [165:16]
|       |       |       |--IDENT -> doStuff [165:9]
|       |       |       |--ELIST -> ELIST [165:17]
|       |       |       `--RPAREN -> ) [165:17]
|       |       |--SEMI -> ; [165:19]
|       |       |--LITERAL_FOR -> for [167:9]
|       |       |   |--LPAREN -> ( [167:13]
|       |       |   |--FOR_INIT -> FOR_INIT [167:14]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [167:14]
|       |       |   |       |--MODIFIERS -> MODIFIERS [167:14]
|       |       |   |       |--TYPE -> TYPE [167:14]
|       |       |   |       |   `--LITERAL_INT -> int [167:14]
|       |       |   |       |--IDENT -> i [167:18]
|       |       |   |       `--ASSIGN -> = [167:20]
|       |       |   |           `--EXPR -> EXPR [167:22]
|       |       |   |               `--NUM_INT -> 0 [167:22]
|       |       |   |--SEMI -> ; [167:24]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [167:28]
|       |       |   |   `--EXPR -> EXPR [167:28]
|       |       |   |       `--LT -> < [167:28]
|       |       |   |           |--IDENT -> i [167:26]
|       |       |   |           `--NUM_INT -> 5 [167:30]
|       |       |   |--SEMI -> ; [167:31]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [167:34]
|       |       |   |   `--ELIST -> ELIST [167:34]
|       |       |   |       `--EXPR -> EXPR [167:34]
|       |       |   |           `--POST_INC -> ++ [167:34]
|       |       |   |               `--IDENT -> i [167:33]
|       |       |   |--RPAREN -> ) [167:36]
|       |       |   `--SLIST -> { [167:38]
|       |       |       `--RCURLY -> } [169:9]
|       |       `--RCURLY -> } [170:5]
|       |--VARIABLE_DEF -> VARIABLE_DEF [174:5]
|       |   |--MODIFIERS -> MODIFIERS [174:5]
|       |   |   `--LITERAL_PRIVATE -> private [174:5]
|       |   |--TYPE -> TYPE [174:13]
|       |   |   `--LITERAL_INT -> int [174:13]
|       |   |--IDENT -> i [174:17]
|       |   `--SEMI -> ; [174:19]
|       |--VARIABLE_DEF -> VARIABLE_DEF [176:5]
|       |   |--MODIFIERS -> MODIFIERS [176:5]
|       |   |   `--LITERAL_PRIVATE -> private [176:5]
|       |   |--TYPE -> TYPE [176:13]
|       |   |   `--LITERAL_INT -> int [176:13]
|       |   |--IDENT -> i1 [176:17]
|       |   `--SEMI -> ; [176:28]
|       |--COMMA -> , [176:19]
|       |--VARIABLE_DEF -> VARIABLE_DEF [176:5]
|       |   |--MODIFIERS -> MODIFIERS [176:5]
|       |   |   `--LITERAL_PRIVATE -> private [176:5]
|       |   |--TYPE -> TYPE [176:13]
|       |   |   `--LITERAL_INT -> int [176:13]
|       |   `--IDENT -> i2 [176:21]
|       |--COMMA -> , [176:23]
|       |--VARIABLE_DEF -> VARIABLE_DEF [176:5]
|       |   |--MODIFIERS -> MODIFIERS [176:5]
|       |   |   `--LITERAL_PRIVATE -> private [176:5]
|       |   |--TYPE -> TYPE [176:13]
|       |   |   `--LITERAL_INT -> int [176:13]
|       |   `--IDENT -> i3 [176:25]
|       |--VARIABLE_DEF -> VARIABLE_DEF [178:5]
|       |   |--MODIFIERS -> MODIFIERS [178:5]
|       |   |   `--LITERAL_PRIVATE -> private [178:5]
|       |   |--TYPE -> TYPE [178:13]
|       |   |   `--LITERAL_INT -> int [178:13]
|       |   |--IDENT -> i4 [178:17]
|       |   `--SEMI -> ; [178:27]
|       |--COMMA -> , [178:19]
|       |--VARIABLE_DEF -> VARIABLE_DEF [178:5]
|       |   |--MODIFIERS -> MODIFIERS [178:5]
|       |   |   `--LITERAL_PRIVATE -> private [178:5]
|       |   |--TYPE -> TYPE [178:13]
|       |   |   `--LITERAL_INT -> int [178:13]
|       |   `--IDENT -> i5 [178:21]
|       |--COMMA -> , [178:23]
|       |--VARIABLE_DEF -> VARIABLE_DEF [178:5]
|       |   |--MODIFIERS -> MODIFIERS [178:5]
|       |   |   `--LITERAL_PRIVATE -> private [178:5]
|       |   |--TYPE -> TYPE [178:13]
|       |   |   `--LITERAL_INT -> int [178:13]
|       |   `--IDENT -> i6 [178:25]
|       |--METHOD_DEF -> METHOD_DEF [181:5]
|       |   |--MODIFIERS -> MODIFIERS [181:5]
|       |   |--TYPE -> TYPE [181:5]
|       |   |   `--LITERAL_VOID -> void [181:5]
|       |   |--IDENT -> bug806243 [181:10]
|       |   |--LPAREN -> ( [181:19]
|       |   |--PARAMETERS -> PARAMETERS [181:20]
|       |   |--RPAREN -> ) [181:20]
|       |   `--SLIST -> { [182:5]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [183:9]
|       |       |   |--MODIFIERS -> MODIFIERS [183:9]
|       |       |   |--TYPE -> TYPE [183:9]
|       |       |   |   `--IDENT -> Object [183:9]
|       |       |   |--IDENT -> o [183:16]
|       |       |   `--ASSIGN -> = [183:18]
|       |       |       `--EXPR -> EXPR [183:20]
|       |       |           `--LITERAL_NEW -> new [183:20]
|       |       |               |--IDENT -> InputAntlr4AstRegressionKeywordsAndOperators [183:24]
|       |       |               |--LPAREN -> ( [183:68]
|       |       |               |--ELIST -> ELIST [183:69]
|       |       |               |--RPAREN -> ) [183:69]
|       |       |               `--OBJBLOCK -> OBJBLOCK [183:71]
|       |       |                   |--LCURLY -> { [183:71]
|       |       |                   |--VARIABLE_DEF -> VARIABLE_DEF [184:13]
|       |       |                   |   |--MODIFIERS -> MODIFIERS [184:13]
|       |       |                   |   |   `--LITERAL_PRIVATE -> private [184:13]
|       |       |                   |   |--TYPE -> TYPE [184:21]
|       |       |                   |   |   `--LITERAL_INT -> int [184:21]
|       |       |                   |   |--IDENT -> j [184:25]
|       |       |                   |   `--SEMI -> ; [184:27]
|       |       |                   `--RCURLY -> } [186:9]
|       |       |--SEMI -> ; [186:10]
|       |       `--RCURLY -> } [187:5]
|       |--METHOD_DEF -> METHOD_DEF [189:5]
|       |   |--MODIFIERS -> MODIFIERS [189:5]
|       |   |--TYPE -> TYPE [189:5]
|       |   |   `--LITERAL_VOID -> void [189:5]
|       |   |--IDENT -> doStuff [189:10]
|       |   |--LPAREN -> ( [189:17]
|       |   |--PARAMETERS -> PARAMETERS [189:18]
|       |   |--RPAREN -> ) [189:18]
|       |   `--SLIST -> { [189:20]
|       |       `--RCURLY -> } [190:5]
|       `--RCURLY -> } [191:1]
|--INTERFACE_DEF -> INTERFACE_DEF [198:1]
|   |--MODIFIERS -> MODIFIERS [198:1]
|   |--LITERAL_INTERFACE -> interface [198:1]
|   |--IDENT -> IFoo [198:11]
|   `--OBJBLOCK -> OBJBLOCK [199:1]
|       |--LCURLY -> { [199:1]
|       |--METHOD_DEF -> METHOD_DEF [200:5]
|       |   |--MODIFIERS -> MODIFIERS [200:5]
|       |   |--TYPE -> TYPE [200:5]
|       |   |   `--LITERAL_VOID -> void [200:5]
|       |   |--IDENT -> foo [200:10]
|       |   |--LPAREN -> ( [200:13]
|       |   |--PARAMETERS -> PARAMETERS [200:14]
|       |   |--RPAREN -> ) [200:14]
|       |   `--SEMI -> ; [200:16]
|       `--RCURLY -> } [202:1]
`--CLASS_DEF -> CLASS_DEF [209:1]
    |--MODIFIERS -> MODIFIERS [209:1]
    |--LITERAL_CLASS -> class [209:1]
    |--IDENT -> SpecialCasesInForLoop [209:7]
    `--OBJBLOCK -> OBJBLOCK [210:1]
        |--LCURLY -> { [210:1]
        |--METHOD_DEF -> METHOD_DEF [211:5]
        |   |--MODIFIERS -> MODIFIERS [211:5]
        |   |--TYPE -> TYPE [211:5]
        |   |   `--LITERAL_VOID -> void [211:5]
        |   |--IDENT -> forIterator [211:10]
        |   |--LPAREN -> ( [211:21]
        |   |--PARAMETERS -> PARAMETERS [211:22]
        |   |--RPAREN -> ) [211:22]
        |   `--SLIST -> { [212:5]
        |       |--LITERAL_FOR -> for [214:9]
        |       |   |--LPAREN -> ( [214:13]
        |       |   |--FOR_INIT -> FOR_INIT [214:14]
        |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [214:14]
        |       |   |       |--MODIFIERS -> MODIFIERS [214:14]
        |       |   |       |--TYPE -> TYPE [214:14]
        |       |   |       |   `--LITERAL_INT -> int [214:14]
        |       |   |       |--IDENT -> i [214:18]
        |       |   |       `--ASSIGN -> = [214:20]
        |       |   |           `--EXPR -> EXPR [214:22]
        |       |   |               `--NUM_INT -> 0 [214:22]
        |       |   |--SEMI -> ; [214:23]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [214:29]
        |       |   |   `--EXPR -> EXPR [214:29]
        |       |   |       `--LT -> < [214:29]
        |       |   |           |--POST_INC -> ++ [214:26]
        |       |   |           |   `--IDENT -> i [214:25]
        |       |   |           `--NUM_INT -> 5 [214:31]
        |       |   |--SEMI -> ; [214:32]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [214:33]
        |       |   |--RPAREN -> ) [214:33]
        |       |   `--SLIST -> { [214:35]
        |       |       `--RCURLY -> } [216:5]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [220:5]
        |       |   |--MODIFIERS -> MODIFIERS [220:5]
        |       |   |--TYPE -> TYPE [220:5]
        |       |   |   `--LITERAL_INT -> int [220:5]
        |       |   |--IDENT -> i [220:9]
        |       |   `--ASSIGN -> = [220:11]
        |       |       `--EXPR -> EXPR [220:13]
        |       |           `--NUM_INT -> 0 [220:13]
        |       |--SEMI -> ; [220:14]
        |       |--LITERAL_FOR -> for [221:5]
        |       |   |--LPAREN -> ( [221:9]
        |       |   |--FOR_INIT -> FOR_INIT [221:11]
        |       |   |--SEMI -> ; [221:11]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [221:15]
        |       |   |   `--EXPR -> EXPR [221:15]
        |       |   |       `--LT -> < [221:15]
        |       |   |           |--IDENT -> i [221:13]
        |       |   |           `--NUM_INT -> 5 [221:17]
        |       |   |--SEMI -> ; [221:18]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [221:21]
        |       |   |   `--ELIST -> ELIST [221:21]
        |       |   |       `--EXPR -> EXPR [221:21]
        |       |   |           `--POST_INC -> ++ [221:21]
        |       |   |               `--IDENT -> i [221:20]
        |       |   |--RPAREN -> ) [221:24]
        |       |   `--SLIST -> { [221:26]
        |       |       `--RCURLY -> } [223:5]
        |       |--LITERAL_FOR -> for [224:9]
        |       |   |--LPAREN -> ( [224:13]
        |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [224:14]
        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [224:14]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [224:14]
        |       |   |   |   |--TYPE -> TYPE [224:14]
        |       |   |   |   |   `--LITERAL_INT -> int [224:14]
        |       |   |   |   `--IDENT -> anInt [224:18]
        |       |   |   |--COLON -> : [224:24]
        |       |   |   `--EXPR -> EXPR [224:37]
        |       |   |       `--METHOD_CALL -> ( [224:37]
        |       |   |           |--IDENT -> getSomeInts [224:26]
        |       |   |           |--ELIST -> ELIST [224:38]
        |       |   |           `--RPAREN -> ) [224:38]
        |       |   |--RPAREN -> ) [224:39]
        |       |   `--SLIST -> { [224:41]
        |       |       `--RCURLY -> } [226:9]
        |       `--RCURLY -> } [227:5]
        |--METHOD_DEF -> METHOD_DEF [229:5]
        |   |--MODIFIERS -> MODIFIERS [229:5]
        |   |--TYPE -> TYPE [229:5]
        |   |   |--LITERAL_INT -> int [229:5]
        |   |   `--ARRAY_DECLARATOR -> [ [229:8]
        |   |       `--RBRACK -> ] [229:9]
        |   |--IDENT -> getSomeInts [229:11]
        |   |--LPAREN -> ( [229:22]
        |   |--PARAMETERS -> PARAMETERS [229:23]
        |   |--RPAREN -> ) [229:23]
        |   `--SLIST -> { [229:25]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [230:9]
        |       |   |--MODIFIERS -> MODIFIERS [230:9]
        |       |   |--TYPE -> TYPE [230:9]
        |       |   |   `--LITERAL_INT -> int [230:9]
        |       |   |--IDENT -> i [230:13]
        |       |   `--ASSIGN -> = [230:15]
        |       |       `--EXPR -> EXPR [230:17]
        |       |           `--TYPECAST -> ( [230:17]
        |       |               |--TYPE -> TYPE [230:18]
        |       |               |   `--LITERAL_INT -> int [230:18]
        |       |               |--RPAREN -> ) [230:21]
        |       |               |--LPAREN -> ( [230:23]
        |       |               |--DIV -> / [230:27]
        |       |               |   |--NUM_INT -> 2 [230:25]
        |       |               |   `--NUM_INT -> 3 [230:29]
        |       |               `--RPAREN -> ) [230:31]
        |       |--SEMI -> ; [230:32]
        |       |--LITERAL_RETURN -> return [231:9]
        |       |   |--EXPR -> EXPR [231:16]
        |       |   |   `--LITERAL_NULL -> null [231:16]
        |       |   `--SEMI -> ; [231:20]
        |       `--RCURLY -> } [232:5]
        |--METHOD_DEF -> METHOD_DEF [234:5]
        |   |--MODIFIERS -> MODIFIERS [234:5]
        |   |   `--LITERAL_PUBLIC -> public [234:5]
        |   |--TYPE -> TYPE [234:12]
        |   |   `--LITERAL_VOID -> void [234:12]
        |   |--IDENT -> myMethod [234:17]
        |   |--LPAREN -> ( [234:25]
        |   |--PARAMETERS -> PARAMETERS [234:26]
        |   |--RPAREN -> ) [234:26]
        |   `--SLIST -> { [234:28]
        |       |--EXPR -> EXPR [238:16]
        |       |   `--METHOD_CALL -> ( [238:16]
        |       |       |--DOT -> . [238:10]
        |       |       |   |--LITERAL_NEW -> new [235:9]
        |       |       |   |   |--IDENT -> Thread [235:13]
        |       |       |   |   |--LPAREN -> ( [235:19]
        |       |       |   |   |--ELIST -> ELIST [235:20]
        |       |       |   |   |--RPAREN -> ) [235:20]
        |       |       |   |   `--OBJBLOCK -> OBJBLOCK [235:22]
        |       |       |   |       |--LCURLY -> { [235:22]
        |       |       |   |       |--METHOD_DEF -> METHOD_DEF [236:13]
        |       |       |   |       |   |--MODIFIERS -> MODIFIERS [236:13]
        |       |       |   |       |   |   `--LITERAL_PUBLIC -> public [236:13]
        |       |       |   |       |   |--TYPE -> TYPE [236:20]
        |       |       |   |       |   |   `--LITERAL_VOID -> void [236:20]
        |       |       |   |       |   |--IDENT -> run [236:25]
        |       |       |   |       |   |--LPAREN -> ( [236:28]
        |       |       |   |       |   |--PARAMETERS -> PARAMETERS [236:29]
        |       |       |   |       |   |--RPAREN -> ) [236:29]
        |       |       |   |       |   `--SLIST -> { [236:31]
        |       |       |   |       |       `--RCURLY -> } [237:13]
        |       |       |   |       `--RCURLY -> } [238:9]
        |       |       |   `--IDENT -> start [238:11]
        |       |       |--ELIST -> ELIST [238:17]
        |       |       `--RPAREN -> ) [238:17]
        |       |--SEMI -> ; [238:18]
        |       `--RCURLY -> } [239:5]
        |--METHOD_DEF -> METHOD_DEF [241:5]
        |   |--MODIFIERS -> MODIFIERS [241:5]
        |   |   `--LITERAL_PUBLIC -> public [241:5]
        |   |--TYPE -> TYPE [241:12]
        |   |   `--LITERAL_VOID -> void [241:12]
        |   |--IDENT -> foo [241:17]
        |   |--LPAREN -> ( [241:20]
        |   |--PARAMETERS -> PARAMETERS [241:30]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [241:30]
        |   |   |   |--MODIFIERS -> MODIFIERS [241:30]
        |   |   |   |--TYPE -> TYPE [241:30]
        |   |   |   |   `--DOT -> . [241:30]
        |   |   |   |       |--DOT -> . [241:25]
        |   |   |   |       |   |--IDENT -> java [241:21]
        |   |   |   |       |   `--IDENT -> util [241:26]
        |   |   |   |       |--IDENT -> List [241:31]
        |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [241:35]
        |   |   |   |           |--GENERIC_START -> < [241:35]
        |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [241:36]
        |   |   |   |           |   |--WILDCARD_TYPE -> ? [241:36]
        |   |   |   |           |   `--TYPE_UPPER_BOUNDS -> extends [241:38]
        |   |   |   |           |       |--IDENT -> String [241:46]
        |   |   |   |           |       `--ARRAY_DECLARATOR -> [ [241:52]
        |   |   |   |           |           `--RBRACK -> ] [241:53]
        |   |   |   |           `--GENERIC_END -> > [241:54]
        |   |   |   `--IDENT -> bar [241:56]
        |   |   |--COMMA -> , [241:59]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [241:61]
        |   |       |--MODIFIERS -> MODIFIERS [241:61]
        |   |       |--TYPE -> TYPE [241:61]
        |   |       |   |--IDENT -> Comparable [241:61]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [241:71]
        |   |       |       |--GENERIC_START -> < [241:71]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [241:72]
        |   |       |       |   |--WILDCARD_TYPE -> ? [241:72]
        |   |       |       |   `--TYPE_LOWER_BOUNDS -> super [241:74]
        |   |       |       |       |--IDENT -> Object [241:80]
        |   |       |       |       `--ARRAY_DECLARATOR -> [ [241:86]
        |   |       |       |           `--RBRACK -> ] [241:87]
        |   |       |       `--GENERIC_END -> > [241:88]
        |   |       `--IDENT -> baz [241:90]
        |   |--RPAREN -> ) [241:93]
        |   `--SLIST -> { [241:95]
        |       `--RCURLY -> } [241:97]
        |--METHOD_DEF -> METHOD_DEF [243:5]
        |   |--MODIFIERS -> MODIFIERS [243:5]
        |   |   `--LITERAL_PUBLIC -> public [243:5]
        |   |--TYPE -> TYPE [243:12]
        |   |   `--LITERAL_VOID -> void [243:12]
        |   |--IDENT -> mySuperMethod [243:17]
        |   |--LPAREN -> ( [243:30]
        |   |--PARAMETERS -> PARAMETERS [243:31]
        |   |--RPAREN -> ) [243:31]
        |   `--SLIST -> { [243:33]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [244:9]
        |       |   |--MODIFIERS -> MODIFIERS [244:9]
        |       |   |--TYPE -> TYPE [244:9]
        |       |   |   |--IDENT -> Runnable [244:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [244:17]
        |       |   |       `--RBRACK -> ] [244:18]
        |       |   |--IDENT -> runs [244:20]
        |       |   `--ASSIGN -> = [244:25]
        |       |       `--EXPR -> EXPR [244:27]
        |       |           `--LITERAL_NEW -> new [244:27]
        |       |               |--IDENT -> Runnable [244:31]
        |       |               |--ARRAY_DECLARATOR -> [ [244:39]
        |       |               |   `--RBRACK -> ] [244:40]
        |       |               `--ARRAY_INIT -> { [244:42]
        |       |                   |--EXPR -> EXPR [244:43]
        |       |                   |   `--LITERAL_NEW -> new [244:43]
        |       |                   |       |--IDENT -> Runnable [244:47]
        |       |                   |       |--LPAREN -> ( [244:55]
        |       |                   |       |--ELIST -> ELIST [244:56]
        |       |                   |       |--RPAREN -> ) [244:56]
        |       |                   |       `--OBJBLOCK -> OBJBLOCK [244:58]
        |       |                   |           |--LCURLY -> { [244:58]
        |       |                   |           |--METHOD_DEF -> METHOD_DEF [245:17]
        |       |                   |           |   |--MODIFIERS -> MODIFIERS [245:17]
        |       |                   |           |   |   `--LITERAL_PUBLIC -> public [245:17]
        |       |                   |           |   |--TYPE -> TYPE [245:24]
        |       |                   |           |   |   `--LITERAL_VOID -> void [245:24]
        |       |                   |           |   |--IDENT -> run [245:29]
        |       |                   |           |   |--LPAREN -> ( [245:32]
        |       |                   |           |   |--PARAMETERS -> PARAMETERS [245:33]
        |       |                   |           |   |--RPAREN -> ) [245:33]
        |       |                   |           |   `--SLIST -> { [245:35]
        |       |                   |           |       `--RCURLY -> } [246:17]
        |       |                   |           `--RCURLY -> } [247:13]
        |       |                   |--COMMA -> , [247:14]
        |       |                   |--EXPR -> EXPR [248:13]
        |       |                   |   `--LITERAL_NEW -> new [248:13]
        |       |                   |       |--IDENT -> Runnable [248:17]
        |       |                   |       |--LPAREN -> ( [248:25]
        |       |                   |       |--ELIST -> ELIST [248:26]
        |       |                   |       |--RPAREN -> ) [248:26]
        |       |                   |       `--OBJBLOCK -> OBJBLOCK [248:28]
        |       |                   |           |--LCURLY -> { [248:28]
        |       |                   |           |--METHOD_DEF -> METHOD_DEF [249:17]
        |       |                   |           |   |--MODIFIERS -> MODIFIERS [249:17]
        |       |                   |           |   |   `--LITERAL_PUBLIC -> public [249:17]
        |       |                   |           |   |--TYPE -> TYPE [249:24]
        |       |                   |           |   |   `--LITERAL_VOID -> void [249:24]
        |       |                   |           |   |--IDENT -> run [249:29]
        |       |                   |           |   |--LPAREN -> ( [249:32]
        |       |                   |           |   |--PARAMETERS -> PARAMETERS [249:33]
        |       |                   |           |   |--RPAREN -> ) [249:33]
        |       |                   |           |   `--SLIST -> { [249:35]
        |       |                   |           |       `--RCURLY -> } [250:17]
        |       |                   |           `--RCURLY -> } [251:13]
        |       |                   `--RCURLY -> } [251:14]
        |       |--SEMI -> ; [251:15]
        |       |--EXPR -> EXPR [254:5]
        |       |   `--METHOD_CALL -> ( [254:5]
        |       |       |--DOT -> . [253:1]
        |       |       |   |--INDEX_OP -> [ [252:13]
        |       |       |   |   |--IDENT -> runs [252:9]
        |       |       |   |   |--EXPR -> EXPR [252:14]
        |       |       |   |   |   `--NUM_INT -> 0 [252:14]
        |       |       |   |   `--RBRACK -> ] [252:15]
        |       |       |   `--IDENT -> run [254:2]
        |       |       |--ELIST -> ELIST [254:6]
        |       |       `--RPAREN -> ) [254:6]
        |       |--SEMI -> ; [255:1]
        |       `--RCURLY -> } [256:5]
        |--METHOD_DEF -> METHOD_DEF [258:5]
        |   |--MODIFIERS -> MODIFIERS [258:5]
        |   |   `--LITERAL_PUBLIC -> public [258:5]
        |   |--TYPE -> TYPE [258:12]
        |   |   `--LITERAL_VOID -> void [258:12]
        |   |--IDENT -> testNullSemi [258:17]
        |   |--LPAREN -> ( [258:29]
        |   |--PARAMETERS -> PARAMETERS [258:30]
        |   |--RPAREN -> ) [258:30]
        |   `--SLIST -> { [258:32]
        |       |--LITERAL_RETURN -> return [259:9]
        |       |   `--SEMI -> ; [259:16]
        |       `--RCURLY -> } [260:5]
        |--METHOD_DEF -> METHOD_DEF [262:5]
        |   |--MODIFIERS -> MODIFIERS [262:5]
        |   |   `--LITERAL_PUBLIC -> public [262:5]
        |   |--TYPE -> TYPE [262:12]
        |   |   `--LITERAL_VOID -> void [262:12]
        |   |--IDENT -> register [262:17]
        |   |--LPAREN -> ( [262:25]
        |   |--PARAMETERS -> PARAMETERS [262:26]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [262:26]
        |   |       |--MODIFIERS -> MODIFIERS [262:26]
        |   |       |--TYPE -> TYPE [262:26]
        |   |       |   `--IDENT -> Object [262:26]
        |   |       `--IDENT -> obj [262:33]
        |   |--RPAREN -> ) [262:36]
        |   `--SLIST -> { [262:38]
        |       `--RCURLY -> } [262:40]
        |--METHOD_DEF -> METHOD_DEF [264:5]
        |   |--MODIFIERS -> MODIFIERS [264:5]
        |   |   `--LITERAL_PUBLIC -> public [264:5]
        |   |--TYPE -> TYPE [264:12]
        |   |   `--LITERAL_VOID -> void [264:12]
        |   |--IDENT -> doSomething [264:17]
        |   |--LPAREN -> ( [264:28]
        |   |--PARAMETERS -> PARAMETERS [264:29]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [264:29]
        |   |       |--MODIFIERS -> MODIFIERS [264:29]
        |   |       |--TYPE -> TYPE [264:29]
        |   |       |   |--IDENT -> String [264:29]
        |   |       |   `--ARRAY_DECLARATOR -> [ [264:40]
        |   |       |       `--RBRACK -> ] [264:41]
        |   |       `--IDENT -> args [264:36]
        |   |--RPAREN -> ) [264:42]
        |   `--SLIST -> { [264:44]
        |       |--EXPR -> EXPR [265:17]
        |       |   `--METHOD_CALL -> ( [265:17]
        |       |       |--IDENT -> register [265:9]
        |       |       |--ELIST -> ELIST [265:27]
        |       |       |   `--EXPR -> EXPR [265:27]
        |       |       |       `--DOT -> . [265:27]
        |       |       |           |--LITERAL_BOOLEAN -> boolean [265:18]
        |       |       |           |--ARRAY_DECLARATOR -> [ [265:25]
        |       |       |           |   `--RBRACK -> ] [265:26]
        |       |       |           `--LITERAL_CLASS -> class [265:28]
        |       |       `--RPAREN -> ) [265:33]
        |       |--SEMI -> ; [265:34]
        |       |--EXPR -> EXPR [266:17]
        |       |   `--METHOD_CALL -> ( [266:17]
        |       |       |--IDENT -> register [266:9]
        |       |       |--ELIST -> ELIST [266:19]
        |       |       |   `--EXPR -> EXPR [266:19]
        |       |       |       `--IDENT -> args [266:19]
        |       |       `--RPAREN -> ) [266:24]
        |       |--SEMI -> ; [266:25]
        |       `--RCURLY -> } [267:5]
        |--METHOD_DEF -> METHOD_DEF [269:5]
        |   |--MODIFIERS -> MODIFIERS [269:5]
        |   |   `--LITERAL_PUBLIC -> public [269:5]
        |   |--TYPE -> TYPE [269:12]
        |   |   `--LITERAL_VOID -> void [269:12]
        |   |--IDENT -> parentheses [269:17]
        |   |--LPAREN -> ( [269:28]
        |   |--PARAMETERS -> PARAMETERS [269:29]
        |   |--RPAREN -> ) [269:29]
        |   `--SLIST -> { [269:31]
        |       |--EXPR -> EXPR [271:1]
        |       |   `--METHOD_CALL -> ( [271:1]
        |       |       |--IDENT -> testNullSemi [270:9]
        |       |       |--ELIST -> ELIST [272:1]
        |       |       `--RPAREN -> ) [272:1]
        |       |--SEMI -> ; [273:1]
        |       `--RCURLY -> } [274:5]
        |--METHOD_DEF -> METHOD_DEF [276:5]
        |   |--MODIFIERS -> MODIFIERS [276:5]
        |   |   |--LITERAL_PUBLIC -> public [276:5]
        |   |   `--LITERAL_STATIC -> static [276:12]
        |   |--TYPE -> TYPE [276:19]
        |   |   `--LITERAL_VOID -> void [276:19]
        |   |--IDENT -> testNoWhitespaceBeforeEllipses [276:24]
        |   |--LPAREN -> ( [276:54]
        |   |--PARAMETERS -> PARAMETERS [276:55]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [276:55]
        |   |       |--MODIFIERS -> MODIFIERS [276:55]
        |   |       |--TYPE -> TYPE [276:55]
        |   |       |   `--IDENT -> String [276:55]
        |   |       |--ELLIPSIS -> ... [276:62]
        |   |       `--IDENT -> args [276:66]
        |   |--RPAREN -> ) [276:70]
        |   `--SLIST -> { [276:72]
        |       `--RCURLY -> } [277:5]
        |--METHOD_DEF -> METHOD_DEF [278:5]
        |   |--MODIFIERS -> MODIFIERS [278:5]
        |   |   `--LITERAL_PUBLIC -> public [278:5]
        |   |--TYPE -> TYPE [278:12]
        |   |   `--IDENT -> String [278:12]
        |   |--IDENT -> test [278:19]
        |   |--LPAREN -> ( [278:23]
        |   |--PARAMETERS -> PARAMETERS [278:24]
        |   |--RPAREN -> ) [278:24]
        |   `--SLIST -> { [278:26]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [279:9]
        |       |   |--MODIFIERS -> MODIFIERS [279:9]
        |       |   |--TYPE -> TYPE [279:9]
        |       |   |   `--LITERAL_INT -> int [279:9]
        |       |   |--IDENT -> pc [279:13]
        |       |   `--ASSIGN -> = [279:16]
        |       |       `--EXPR -> EXPR [279:18]
        |       |           `--NUM_INT -> 0 [279:18]
        |       |--SEMI -> ; [279:19]
        |       |--LITERAL_RETURN -> return [280:9]
        |       |   |--EXPR -> EXPR [280:42]
        |       |   |   `--METHOD_CALL -> ( [280:42]
        |       |   |       |--DOT -> . [280:32]
        |       |   |       |   |--LPAREN -> ( [280:16]
        |       |   |       |   |--PLUS -> + [280:28]
        |       |   |       |   |   |--LPAREN -> ( [280:17]
        |       |   |       |   |   |--PLUS -> + [280:24]
        |       |   |       |   |   |   |--NUM_INT -> 100000 [280:18]
        |       |   |       |   |   |   `--IDENT -> pc [280:25]
        |       |   |       |   |   |--RPAREN -> ) [280:27]
        |       |   |       |   |   `--STRING_LITERAL -> "" [280:29]
        |       |   |       |   |--RPAREN -> ) [280:31]
        |       |   |       |   `--IDENT -> substring [280:33]
        |       |   |       |--ELIST -> ELIST [280:43]
        |       |   |       |   `--EXPR -> EXPR [280:43]
        |       |   |       |       `--NUM_INT -> 1 [280:43]
        |       |   |       `--RPAREN -> ) [280:44]
        |       |   `--SEMI -> ; [280:45]
        |       `--RCURLY -> } [281:5]
        `--RCURLY -> } [282:1]
