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