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 -> InputAntlr4AstRegressionTrickySwitch [3:14]
    `--OBJBLOCK -> OBJBLOCK [3:51]
        |--LCURLY -> { [3:51]
        |--METHOD_DEF -> METHOD_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |   |--LITERAL_PRIVATE -> private [5:5]
        |   |   `--LITERAL_STATIC -> static [5:13]
        |   |--TYPE -> TYPE [5:20]
        |   |   `--LITERAL_VOID -> void [5:20]
        |   |--IDENT -> fooSwitch [5:25]
        |   |--LPAREN -> ( [5:34]
        |   |--PARAMETERS -> PARAMETERS [5:35]
        |   |--RPAREN -> ) [5:35]
        |   `--SLIST -> { [5:37]
        |       |--LITERAL_SWITCH -> switch [6:9]
        |       |   |--LPAREN -> ( [6:15]
        |       |   |--EXPR -> EXPR [6:16]
        |       |   |   `--STRING_LITERAL -> "" [6:16]
        |       |   |--RPAREN -> ) [6:18]
        |       |   |--LCURLY -> { [6:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [7:13]
        |       |   |   |--LITERAL_CASE -> case [7:13]
        |       |   |   |   |--EXPR -> EXPR [7:18]
        |       |   |   |   |   `--STRING_LITERAL -> "0" [7:18]
        |       |   |   |   `--COLON -> : [7:21]
        |       |   |   |--LITERAL_CASE -> case [8:13]
        |       |   |   |   |--EXPR -> EXPR [8:18]
        |       |   |   |   |   `--STRING_LITERAL -> "1" [8:18]
        |       |   |   |   `--COLON -> : [8:21]
        |       |   |   `--SLIST -> SLIST [10:21]
        |       |   |       |--EXPR -> EXPR [10:21]
        |       |   |       |   `--METHOD_CALL -> ( [10:21]
        |       |   |       |       |--IDENT -> foo1 [10:17]
        |       |   |       |       |--ELIST -> ELIST [10:22]
        |       |   |       |       `--RPAREN -> ) [10:22]
        |       |   |       |--SEMI -> ; [10:23]
        |       |   |       `--LITERAL_BREAK -> break [11:17]
        |       |   |           `--SEMI -> ; [11:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [12:13]
        |       |   |   |--LITERAL_CASE -> case [12:13]
        |       |   |   |   |--EXPR -> EXPR [12:18]
        |       |   |   |   |   `--STRING_LITERAL -> "2" [12:18]
        |       |   |   |   `--COLON -> : [12:21]
        |       |   |   `--SLIST -> SLIST [15:21]
        |       |   |       |--EXPR -> EXPR [15:21]
        |       |   |       |   `--METHOD_CALL -> ( [15:21]
        |       |   |       |       |--IDENT -> foo1 [15:17]
        |       |   |       |       |--ELIST -> ELIST [15:22]
        |       |   |       |       `--RPAREN -> ) [15:22]
        |       |   |       |--SEMI -> ; [15:23]
        |       |   |       `--LITERAL_BREAK -> break [17:17]
        |       |   |           `--SEMI -> ; [17:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [18:13]
        |       |   |   |--LITERAL_CASE -> case [18:13]
        |       |   |   |   |--EXPR -> EXPR [18:18]
        |       |   |   |   |   `--STRING_LITERAL -> "3" [18:18]
        |       |   |   |   `--COLON -> : [18:21]
        |       |   |   `--SLIST -> SLIST [20:21]
        |       |   |       |--EXPR -> EXPR [20:21]
        |       |   |       |   `--METHOD_CALL -> ( [20:21]
        |       |   |       |       |--IDENT -> foo1 [20:17]
        |       |   |       |       |--ELIST -> ELIST [20:22]
        |       |   |       |       `--RPAREN -> ) [20:22]
        |       |   |       |--SEMI -> ; [20:23]
        |       |   |       `--LITERAL_BREAK -> break [22:17]
        |       |   |           `--SEMI -> ; [22:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [23:13]
        |       |   |   |--LITERAL_CASE -> case [23:13]
        |       |   |   |   |--EXPR -> EXPR [23:18]
        |       |   |   |   |   `--STRING_LITERAL -> "5" [23:18]
        |       |   |   |   `--COLON -> : [23:21]
        |       |   |   `--SLIST -> SLIST [24:21]
        |       |   |       |--EXPR -> EXPR [24:21]
        |       |   |       |   `--METHOD_CALL -> ( [24:21]
        |       |   |       |       |--IDENT -> foo1 [24:17]
        |       |   |       |       |--ELIST -> ELIST [24:22]
        |       |   |       |       `--RPAREN -> ) [24:22]
        |       |   |       `--SEMI -> ; [24:23]
        |       |   |--CASE_GROUP -> CASE_GROUP [26:13]
        |       |   |   |--LITERAL_CASE -> case [26:13]
        |       |   |   |   |--EXPR -> EXPR [26:18]
        |       |   |   |   |   `--STRING_LITERAL -> "6" [26:18]
        |       |   |   |   `--COLON -> : [26:21]
        |       |   |   `--SLIST -> SLIST [27:17]
        |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [27:17]
        |       |   |       |   |--MODIFIERS -> MODIFIERS [27:17]
        |       |   |       |   |--TYPE -> TYPE [27:17]
        |       |   |       |   |   `--LITERAL_INT -> int [27:17]
        |       |   |       |   |--IDENT -> k [27:21]
        |       |   |       |   `--ASSIGN -> = [27:23]
        |       |   |       |       `--EXPR -> EXPR [27:25]
        |       |   |       |           `--NUM_INT -> 7 [27:25]
        |       |   |       `--SEMI -> ; [27:26]
        |       |   |--CASE_GROUP -> CASE_GROUP [29:13]
        |       |   |   |--LITERAL_CASE -> case [29:13]
        |       |   |   |   |--EXPR -> EXPR [29:18]
        |       |   |   |   |   `--STRING_LITERAL -> "7" [29:18]
        |       |   |   |   `--COLON -> : [29:21]
        |       |   |   `--SLIST -> SLIST [30:17]
        |       |   |       `--LITERAL_IF -> if [30:17]
        |       |   |           |--LPAREN -> ( [30:20]
        |       |   |           |--EXPR -> EXPR [30:21]
        |       |   |           |   `--LITERAL_TRUE -> true [30:21]
        |       |   |           |--RPAREN -> ) [30:25]
        |       |   |           `--SLIST -> { [30:27]
        |       |   |               `--RCURLY -> } [30:28]
        |       |   |--CASE_GROUP -> CASE_GROUP [32:13]
        |       |   |   |--LITERAL_CASE -> case [32:13]
        |       |   |   |   |--EXPR -> EXPR [32:18]
        |       |   |   |   |   `--STRING_LITERAL -> "8" [32:18]
        |       |   |   |   `--COLON -> : [32:21]
        |       |   |   `--SLIST -> SLIST [33:17]
        |       |   |       `--LITERAL_BREAK -> break [33:17]
        |       |   |           `--SEMI -> ; [33:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [34:13]
        |       |   |   |--LITERAL_CASE -> case [34:13]
        |       |   |   |   |--EXPR -> EXPR [34:18]
        |       |   |   |   |   `--STRING_LITERAL -> "9" [34:18]
        |       |   |   |   `--COLON -> : [34:21]
        |       |   |   `--SLIST -> SLIST [35:21]
        |       |   |       |--EXPR -> EXPR [35:21]
        |       |   |       |   `--METHOD_CALL -> ( [35:21]
        |       |   |       |       |--IDENT -> foo1 [35:17]
        |       |   |       |       |--ELIST -> ELIST [35:22]
        |       |   |       |       `--RPAREN -> ) [35:22]
        |       |   |       `--SEMI -> ; [35:23]
        |       |   |--CASE_GROUP -> CASE_GROUP [37:13]
        |       |   |   |--LITERAL_CASE -> case [37:13]
        |       |   |   |   |--EXPR -> EXPR [37:18]
        |       |   |   |   |   `--STRING_LITERAL -> "10" [37:18]
        |       |   |   |   `--COLON -> : [37:22]
        |       |   |   `--SLIST -> SLIST [37:24]
        |       |   |       `--SLIST -> { [37:24]
        |       |   |           |--LITERAL_IF -> if [38:17]
        |       |   |           |   |--LPAREN -> ( [38:20]
        |       |   |           |   |--EXPR -> EXPR [38:21]
        |       |   |           |   |   `--LITERAL_TRUE -> true [38:21]
        |       |   |           |   |--RPAREN -> ) [38:25]
        |       |   |           |   `--SLIST -> { [38:27]
        |       |   |           |       `--RCURLY -> } [38:28]
        |       |   |           `--RCURLY -> } [40:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [41:13]
        |       |   |   |--LITERAL_CASE -> case [41:13]
        |       |   |   |   |--EXPR -> EXPR [41:18]
        |       |   |   |   |   `--STRING_LITERAL -> "11" [41:18]
        |       |   |   |   `--COLON -> : [41:22]
        |       |   |   `--SLIST -> SLIST [41:24]
        |       |   |       `--SLIST -> { [41:24]
        |       |   |           `--RCURLY -> } [43:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [44:13]
        |       |   |   |--LITERAL_CASE -> case [44:13]
        |       |   |   |   |--EXPR -> EXPR [44:18]
        |       |   |   |   |   `--STRING_LITERAL -> "28" [44:18]
        |       |   |   |   `--COLON -> : [44:22]
        |       |   |   `--SLIST -> SLIST [44:24]
        |       |   |       `--SLIST -> { [44:24]
        |       |   |           `--RCURLY -> } [46:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [47:13]
        |       |   |   |--LITERAL_CASE -> case [47:13]
        |       |   |   |   |--EXPR -> EXPR [47:18]
        |       |   |   |   |   `--STRING_LITERAL -> "12" [47:18]
        |       |   |   |   `--COLON -> : [47:22]
        |       |   |   `--SLIST -> SLIST [47:24]
        |       |   |       `--SLIST -> { [47:24]
        |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [49:17]
        |       |   |           |   |--MODIFIERS -> MODIFIERS [49:17]
        |       |   |           |   |--TYPE -> TYPE [49:17]
        |       |   |           |   |   `--LITERAL_INT -> int [49:17]
        |       |   |           |   `--IDENT -> i [49:21]
        |       |   |           |--SEMI -> ; [49:22]
        |       |   |           `--RCURLY -> } [50:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [51:13]
        |       |   |   |--LITERAL_CASE -> case [51:13]
        |       |   |   |   |--EXPR -> EXPR [51:18]
        |       |   |   |   |   `--STRING_LITERAL -> "13" [51:18]
        |       |   |   |   `--COLON -> : [51:22]
        |       |   |   `--SLIST -> SLIST [51:24]
        |       |   |       `--SLIST -> { [51:24]
        |       |   |           `--RCURLY -> } [53:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [54:13]
        |       |   |   |--LITERAL_CASE -> case [54:13]
        |       |   |   |   |--EXPR -> EXPR [54:18]
        |       |   |   |   |   `--STRING_LITERAL -> "14" [54:18]
        |       |   |   |   `--COLON -> : [54:22]
        |       |   |   `--SLIST -> SLIST [54:24]
        |       |   |       `--SLIST -> { [54:24]
        |       |   |           `--RCURLY -> } [56:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [57:13]
        |       |   |   |--LITERAL_CASE -> case [57:13]
        |       |   |   |   |--EXPR -> EXPR [57:18]
        |       |   |   |   |   `--STRING_LITERAL -> "15" [57:18]
        |       |   |   |   `--COLON -> : [57:22]
        |       |   |   `--SLIST -> SLIST [57:24]
        |       |   |       `--SLIST -> { [57:24]
        |       |   |           |--EXPR -> EXPR [58:21]
        |       |   |           |   `--METHOD_CALL -> ( [58:21]
        |       |   |           |       |--IDENT -> foo1 [58:17]
        |       |   |           |       |--ELIST -> ELIST [58:22]
        |       |   |           |       `--RPAREN -> ) [58:22]
        |       |   |           |--SEMI -> ; [58:23]
        |       |   |           `--RCURLY -> } [60:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [61:13]
        |       |   |   |--LITERAL_CASE -> case [61:13]
        |       |   |   |   |--EXPR -> EXPR [61:18]
        |       |   |   |   |   `--STRING_LITERAL -> "16" [61:18]
        |       |   |   |   `--COLON -> : [61:22]
        |       |   |   `--SLIST -> SLIST [61:24]
        |       |   |       `--SLIST -> { [61:24]
        |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [62:17]
        |       |   |           |   |--MODIFIERS -> MODIFIERS [62:17]
        |       |   |           |   |--TYPE -> TYPE [62:17]
        |       |   |           |   |   `--LITERAL_INT -> int [62:17]
        |       |   |           |   `--IDENT -> a [62:21]
        |       |   |           |--SEMI -> ; [62:22]
        |       |   |           `--RCURLY -> } [63:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [65:13]
        |       |   |   |--LITERAL_CASE -> case [65:13]
        |       |   |   |   |--EXPR -> EXPR [65:18]
        |       |   |   |   |   `--STRING_LITERAL -> "17" [65:18]
        |       |   |   |   `--COLON -> : [65:22]
        |       |   |   `--SLIST -> SLIST [65:24]
        |       |   |       `--SLIST -> { [65:24]
        |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [66:17]
        |       |   |           |   |--MODIFIERS -> MODIFIERS [66:17]
        |       |   |           |   |--TYPE -> TYPE [66:17]
        |       |   |           |   |   `--LITERAL_INT -> int [66:17]
        |       |   |           |   `--IDENT -> a [66:21]
        |       |   |           |--SEMI -> ; [66:22]
        |       |   |           `--RCURLY -> } [67:13]
        |       |   |--CASE_GROUP -> CASE_GROUP [69:17]
        |       |   |   |--LITERAL_CASE -> case [69:17]
        |       |   |   |   |--EXPR -> EXPR [69:22]
        |       |   |   |   |   `--STRING_LITERAL -> "18" [69:22]
        |       |   |   |   `--COLON -> : [69:26]
        |       |   |   `--SLIST -> SLIST [69:28]
        |       |   |       `--SLIST -> { [69:28]
        |       |   |           |--EXPR -> EXPR [69:50]
        |       |   |           |   `--METHOD_CALL -> ( [69:50]
        |       |   |           |       |--DOT -> . [69:36]
        |       |   |           |       |   |--IDENT -> System [69:30]
        |       |   |           |       |   `--IDENT -> lineSeparator [69:37]
        |       |   |           |       |--ELIST -> ELIST [69:51]
        |       |   |           |       `--RPAREN -> ) [69:51]
        |       |   |           |--SEMI -> ; [69:52]
        |       |   |           `--RCURLY -> } [70:17]
        |       |   |--CASE_GROUP -> CASE_GROUP [71:13]
        |       |   |   |--LITERAL_CASE -> case [71:13]
        |       |   |   |   |--EXPR -> EXPR [71:18]
        |       |   |   |   |   `--STRING_LITERAL -> "19" [71:18]
        |       |   |   |   `--COLON -> : [71:22]
        |       |   |   |--LITERAL_CASE -> case [73:13]
        |       |   |   |   |--EXPR -> EXPR [73:18]
        |       |   |   |   |   `--STRING_LITERAL -> "20" [73:18]
        |       |   |   |   `--COLON -> : [73:22]
        |       |   |   |--LITERAL_CASE -> case [75:13]
        |       |   |   |   |--EXPR -> EXPR [75:18]
        |       |   |   |   |   `--STRING_LITERAL -> "21" [75:18]
        |       |   |   |   `--COLON -> : [75:22]
        |       |   |   |--LITERAL_DEFAULT -> default [76:13]
        |       |   |   |   `--COLON -> : [76:20]
        |       |   |   `--SLIST -> SLIST [78:17]
        |       |   |       `--LITERAL_BREAK -> break [78:17]
        |       |   |           `--SEMI -> ; [78:22]
        |       |   `--RCURLY -> } [79:9]
        |       `--RCURLY -> } [80:5]
        |--METHOD_DEF -> METHOD_DEF [82:5]
        |   |--MODIFIERS -> MODIFIERS [82:5]
        |   |   |--LITERAL_PRIVATE -> private [82:5]
        |   |   `--LITERAL_STATIC -> static [82:13]
        |   |--TYPE -> TYPE [82:20]
        |   |   `--LITERAL_VOID -> void [82:20]
        |   |--IDENT -> foo1 [82:25]
        |   |--LPAREN -> ( [82:29]
        |   |--PARAMETERS -> PARAMETERS [82:30]
        |   |--RPAREN -> ) [82:30]
        |   `--SLIST -> { [82:32]
        |       |--LITERAL_IF -> if [83:9]
        |       |   |--LPAREN -> ( [83:12]
        |       |   |--EXPR -> EXPR [83:13]
        |       |   |   `--LITERAL_TRUE -> true [83:13]
        |       |   |--RPAREN -> ) [83:17]
        |       |   `--SLIST -> { [83:19]
        |       |       |--LITERAL_SWITCH -> switch [84:13]
        |       |       |   |--LPAREN -> ( [84:19]
        |       |       |   |--EXPR -> EXPR [84:20]
        |       |       |   |   `--NUM_INT -> 1 [84:20]
        |       |       |   |--RPAREN -> ) [84:21]
        |       |       |   |--LCURLY -> { [84:23]
        |       |       |   |--CASE_GROUP -> CASE_GROUP [85:17]
        |       |       |   |   |--LITERAL_CASE -> case [85:17]
        |       |       |   |   |   |--EXPR -> EXPR [85:22]
        |       |       |   |   |   |   `--NUM_INT -> 0 [85:22]
        |       |       |   |   |   `--COLON -> : [85:23]
        |       |       |   |   |--LITERAL_CASE -> case [87:17]
        |       |       |   |   |   |--EXPR -> EXPR [87:22]
        |       |       |   |   |   |   `--NUM_INT -> 1 [87:22]
        |       |       |   |   |   `--COLON -> : [87:23]
        |       |       |   |   `--SLIST -> SLIST [89:21]
        |       |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [89:21]
        |       |       |   |       |   |--MODIFIERS -> MODIFIERS [89:21]
        |       |       |   |       |   |--TYPE -> TYPE [89:21]
        |       |       |   |       |   |   `--LITERAL_INT -> int [89:21]
        |       |       |   |       |   |--IDENT -> b [89:25]
        |       |       |   |       |   `--ASSIGN -> = [89:27]
        |       |       |   |       |       `--EXPR -> EXPR [89:29]
        |       |       |   |       |           `--NUM_INT -> 10 [89:29]
        |       |       |   |       `--SEMI -> ; [89:31]
        |       |       |   |--CASE_GROUP -> CASE_GROUP [90:17]
        |       |       |   |   `--LITERAL_DEFAULT -> default [90:17]
        |       |       |   |       `--COLON -> : [90:24]
        |       |       |   `--RCURLY -> } [92:13]
        |       |       `--RCURLY -> } [94:9]
        |       `--RCURLY -> } [95:5]
        |--METHOD_DEF -> METHOD_DEF [97:5]
        |   |--MODIFIERS -> MODIFIERS [97:5]
        |   |   `--LITERAL_PUBLIC -> public [97:5]
        |   |--TYPE -> TYPE [97:12]
        |   |   `--LITERAL_VOID -> void [97:12]
        |   |--IDENT -> fooDotInCaseBlock [97:17]
        |   |--LPAREN -> ( [97:34]
        |   |--PARAMETERS -> PARAMETERS [97:35]
        |   |--RPAREN -> ) [97:35]
        |   `--SLIST -> { [97:37]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [98:9]
        |       |   |--MODIFIERS -> MODIFIERS [98:9]
        |       |   |--TYPE -> TYPE [98:9]
        |       |   |   `--LITERAL_INT -> int [98:9]
        |       |   |--IDENT -> i [98:13]
        |       |   `--ASSIGN -> = [98:15]
        |       |       `--EXPR -> EXPR [98:17]
        |       |           `--NUM_INT -> 0 [98:17]
        |       |--SEMI -> ; [98:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [99:9]
        |       |   |--MODIFIERS -> MODIFIERS [99:9]
        |       |   |--TYPE -> TYPE [99:9]
        |       |   |   `--IDENT -> String [99:9]
        |       |   |--IDENT -> s [99:16]
        |       |   `--ASSIGN -> = [99:18]
        |       |       `--EXPR -> EXPR [99:20]
        |       |           `--STRING_LITERAL -> "" [99:20]
        |       |--SEMI -> ; [99:22]
        |       |--LITERAL_SWITCH -> switch [101:9]
        |       |   |--LPAREN -> ( [101:16]
        |       |   |--EXPR -> EXPR [101:17]
        |       |   |   `--IDENT -> i [101:17]
        |       |   |--RPAREN -> ) [101:18]
        |       |   |--LCURLY -> { [101:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [102:13]
        |       |   |   |--LITERAL_CASE -> case [102:13]
        |       |   |   |   |--EXPR -> EXPR [102:18]
        |       |   |   |   |   `--UNARY_MINUS -> - [102:18]
        |       |   |   |   |       `--NUM_INT -> 2 [102:19]
        |       |   |   |   `--COLON -> : [102:20]
        |       |   |   `--SLIST -> SLIST [104:18]
        |       |   |       |--EXPR -> EXPR [104:18]
        |       |   |       |   `--POST_INC -> ++ [104:18]
        |       |   |       |       `--IDENT -> i [104:17]
        |       |   |       `--SEMI -> ; [104:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [106:13]
        |       |   |   |--LITERAL_CASE -> case [106:13]
        |       |   |   |   |--EXPR -> EXPR [106:18]
        |       |   |   |   |   `--NUM_INT -> 0 [106:18]
        |       |   |   |   `--COLON -> : [106:19]
        |       |   |   `--SLIST -> SLIST [108:26]
        |       |   |       |--EXPR -> EXPR [108:26]
        |       |   |       |   `--METHOD_CALL -> ( [108:26]
        |       |   |       |       |--DOT -> . [108:18]
        |       |   |       |       |   |--IDENT -> s [108:17]
        |       |   |       |       |   `--IDENT -> indexOf [108:19]
        |       |   |       |       |--ELIST -> ELIST [108:27]
        |       |   |       |       |   `--EXPR -> EXPR [108:27]
        |       |   |       |       |       `--STRING_LITERAL -> "ignore" [108:27]
        |       |   |       |       `--RPAREN -> ) [108:35]
        |       |   |       `--SEMI -> ; [108:36]
        |       |   |--CASE_GROUP -> CASE_GROUP [110:13]
        |       |   |   |--LITERAL_CASE -> case [110:13]
        |       |   |   |   |--EXPR -> EXPR [110:18]
        |       |   |   |   |   `--UNARY_MINUS -> - [110:18]
        |       |   |   |   |       `--NUM_INT -> 1 [110:19]
        |       |   |   |   `--COLON -> : [110:20]
        |       |   |   `--SLIST -> SLIST [112:27]
        |       |   |       |--EXPR -> EXPR [112:27]
        |       |   |       |   `--METHOD_CALL -> ( [112:27]
        |       |   |       |       |--DOT -> . [112:19]
        |       |   |       |       |   |--IDENT -> s [112:18]
        |       |   |       |       |   `--IDENT -> indexOf [112:20]
        |       |   |       |       |--ELIST -> ELIST [112:28]
        |       |   |       |       |   `--EXPR -> EXPR [112:28]
        |       |   |       |       |       `--STRING_LITERAL -> "no way" [112:28]
        |       |   |       |       `--RPAREN -> ) [112:36]
        |       |   |       `--SEMI -> ; [112:37]
        |       |   |--CASE_GROUP -> CASE_GROUP [114:13]
        |       |   |   |--LITERAL_CASE -> case [114:13]
        |       |   |   |   |--EXPR -> EXPR [114:18]
        |       |   |   |   |   `--NUM_INT -> 1 [114:18]
        |       |   |   |   `--COLON -> : [114:19]
        |       |   |   |--LITERAL_CASE -> case [115:13]
        |       |   |   |   |--EXPR -> EXPR [115:18]
        |       |   |   |   |   `--NUM_INT -> 2 [115:18]
        |       |   |   |   `--COLON -> : [115:19]
        |       |   |   `--SLIST -> SLIST [116:18]
        |       |   |       |--EXPR -> EXPR [116:18]
        |       |   |       |   `--POST_DEC -> -- [116:18]
        |       |   |       |       `--IDENT -> i [116:17]
        |       |   |       `--SEMI -> ; [116:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [118:13]
        |       |   |   |--LITERAL_CASE -> case [118:13]
        |       |   |   |   |--EXPR -> EXPR [118:18]
        |       |   |   |   |   `--NUM_INT -> 3 [118:18]
        |       |   |   |   `--COLON -> : [118:19]
        |       |   |   `--SLIST -> SLIST [118:21]
        |       |   |       `--SLIST -> { [118:21]
        |       |   |           `--RCURLY -> } [118:23]
        |       |   `--RCURLY -> } [122:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [124:9]
        |       |   |--MODIFIERS -> MODIFIERS [124:9]
        |       |   |--TYPE -> TYPE [124:9]
        |       |   |   `--IDENT -> String [124:9]
        |       |   |--IDENT -> breaks [124:16]
        |       |   `--ASSIGN -> = [124:23]
        |       |       `--EXPR -> EXPR [128:13]
        |       |           `--PLUS -> + [128:13]
        |       |               |--PLUS -> + [126:13]
        |       |               |   |--STRING_LITERAL -> "" [124:25]
        |       |               |   `--STRING_LITERAL -> "</table>" [126:15]
        |       |               `--STRING_LITERAL -> "" [128:15]
        |       |--SEMI -> ; [130:9]
        |       `--RCURLY -> } [131:5]
        |--METHOD_DEF -> METHOD_DEF [133:5]
        |   |--MODIFIERS -> MODIFIERS [133:5]
        |   |   `--LITERAL_PUBLIC -> public [133:5]
        |   |--TYPE -> TYPE [133:12]
        |   |   `--LITERAL_VOID -> void [133:12]
        |   |--IDENT -> foo2 [133:17]
        |   |--LPAREN -> ( [133:21]
        |   |--PARAMETERS -> PARAMETERS [133:22]
        |   |--RPAREN -> ) [133:22]
        |   `--SLIST -> { [133:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [134:9]
        |       |   |--MODIFIERS -> MODIFIERS [134:9]
        |       |   |--TYPE -> TYPE [134:9]
        |       |   |   `--LITERAL_INT -> int [134:9]
        |       |   |--IDENT -> a [134:13]
        |       |   `--ASSIGN -> = [134:15]
        |       |       `--EXPR -> EXPR [134:17]
        |       |           `--NUM_INT -> 1 [134:17]
        |       |--SEMI -> ; [134:18]
        |       |--LITERAL_SWITCH -> switch [135:9]
        |       |   |--LPAREN -> ( [135:16]
        |       |   |--EXPR -> EXPR [135:17]
        |       |   |   `--IDENT -> a [135:17]
        |       |   |--RPAREN -> ) [135:18]
        |       |   |--LCURLY -> { [135:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [136:13]
        |       |   |   |--LITERAL_CASE -> case [136:13]
        |       |   |   |   |--EXPR -> EXPR [136:18]
        |       |   |   |   |   `--NUM_INT -> 1 [136:18]
        |       |   |   |   `--COLON -> : [136:19]
        |       |   |   `--LITERAL_DEFAULT -> default [137:13]
        |       |   |       `--COLON -> : [137:20]
        |       |   `--RCURLY -> } [139:9]
        |       `--RCURLY -> } [140:5]
        |--METHOD_DEF -> METHOD_DEF [142:5]
        |   |--MODIFIERS -> MODIFIERS [142:5]
        |   |   `--LITERAL_PUBLIC -> public [142:5]
        |   |--TYPE -> TYPE [142:12]
        |   |   `--LITERAL_VOID -> void [142:12]
        |   |--IDENT -> foo3 [142:17]
        |   |--LPAREN -> ( [142:21]
        |   |--PARAMETERS -> PARAMETERS [142:22]
        |   |--RPAREN -> ) [142:22]
        |   `--SLIST -> { [142:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [143:9]
        |       |   |--MODIFIERS -> MODIFIERS [143:9]
        |       |   |--TYPE -> TYPE [143:9]
        |       |   |   `--LITERAL_INT -> int [143:9]
        |       |   |--IDENT -> a [143:13]
        |       |   `--ASSIGN -> = [143:15]
        |       |       `--EXPR -> EXPR [143:17]
        |       |           `--NUM_INT -> 1 [143:17]
        |       |--SEMI -> ; [143:18]
        |       |--LITERAL_SWITCH -> switch [144:9]
        |       |   |--LPAREN -> ( [144:16]
        |       |   |--EXPR -> EXPR [144:17]
        |       |   |   `--IDENT -> a [144:17]
        |       |   |--RPAREN -> ) [144:18]
        |       |   |--LCURLY -> { [144:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [145:13]
        |       |   |   |--LITERAL_CASE -> case [145:13]
        |       |   |   |   |--EXPR -> EXPR [145:18]
        |       |   |   |   |   `--NUM_INT -> 1 [145:18]
        |       |   |   |   `--COLON -> : [145:19]
        |       |   |   `--LITERAL_DEFAULT -> default [146:13]
        |       |   |       `--COLON -> : [146:20]
        |       |   `--RCURLY -> } [149:9]
        |       `--RCURLY -> } [150:5]
        |--METHOD_DEF -> METHOD_DEF [152:5]
        |   |--MODIFIERS -> MODIFIERS [152:5]
        |   |   `--LITERAL_PUBLIC -> public [152:5]
        |   |--TYPE -> TYPE [152:12]
        |   |   `--LITERAL_VOID -> void [152:12]
        |   |--IDENT -> foo4 [152:17]
        |   |--LPAREN -> ( [152:21]
        |   |--PARAMETERS -> PARAMETERS [152:22]
        |   |--RPAREN -> ) [152:22]
        |   `--SLIST -> { [152:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [153:9]
        |       |   |--MODIFIERS -> MODIFIERS [153:9]
        |       |   |--TYPE -> TYPE [153:9]
        |       |   |   `--LITERAL_INT -> int [153:9]
        |       |   |--IDENT -> a [153:13]
        |       |   `--ASSIGN -> = [153:15]
        |       |       `--EXPR -> EXPR [153:17]
        |       |           `--NUM_INT -> 1 [153:17]
        |       |--SEMI -> ; [153:18]
        |       |--LITERAL_SWITCH -> switch [154:9]
        |       |   |--LPAREN -> ( [154:16]
        |       |   |--EXPR -> EXPR [154:17]
        |       |   |   `--IDENT -> a [154:17]
        |       |   |--RPAREN -> ) [154:18]
        |       |   |--LCURLY -> { [154:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [155:13]
        |       |   |   |--LITERAL_CASE -> case [155:13]
        |       |   |   |   |--EXPR -> EXPR [155:18]
        |       |   |   |   |   `--NUM_INT -> 1 [155:18]
        |       |   |   |   `--COLON -> : [155:19]
        |       |   |   `--SLIST -> SLIST [156:17]
        |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [156:17]
        |       |   |       |   |--MODIFIERS -> MODIFIERS [156:17]
        |       |   |       |   |--TYPE -> TYPE [156:17]
        |       |   |       |   |   `--LITERAL_INT -> int [156:17]
        |       |   |       |   `--IDENT -> b [156:21]
        |       |   |       `--SEMI -> ; [156:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [158:13]
        |       |   |   `--LITERAL_DEFAULT -> default [158:13]
        |       |   |       `--COLON -> : [158:20]
        |       |   `--RCURLY -> } [159:9]
        |       `--RCURLY -> } [160:5]
        |--METHOD_DEF -> METHOD_DEF [162:5]
        |   |--MODIFIERS -> MODIFIERS [162:5]
        |   |   `--LITERAL_PUBLIC -> public [162:5]
        |   |--TYPE -> TYPE [162:12]
        |   |   `--LITERAL_VOID -> void [162:12]
        |   |--IDENT -> foo5 [162:17]
        |   |--LPAREN -> ( [162:21]
        |   |--PARAMETERS -> PARAMETERS [162:22]
        |   |--RPAREN -> ) [162:22]
        |   `--SLIST -> { [162:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [163:9]
        |       |   |--MODIFIERS -> MODIFIERS [163:9]
        |       |   |--TYPE -> TYPE [163:9]
        |       |   |   `--LITERAL_INT -> int [163:9]
        |       |   |--IDENT -> a [163:13]
        |       |   `--ASSIGN -> = [163:15]
        |       |       `--EXPR -> EXPR [163:17]
        |       |           `--NUM_INT -> 1 [163:17]
        |       |--SEMI -> ; [163:18]
        |       |--LITERAL_SWITCH -> switch [164:9]
        |       |   |--LPAREN -> ( [164:16]
        |       |   |--EXPR -> EXPR [164:17]
        |       |   |   `--IDENT -> a [164:17]
        |       |   |--RPAREN -> ) [164:18]
        |       |   |--LCURLY -> { [164:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [165:13]
        |       |   |   |--LITERAL_CASE -> case [165:13]
        |       |   |   |   |--EXPR -> EXPR [165:18]
        |       |   |   |   |   `--NUM_INT -> 1 [165:18]
        |       |   |   |   `--COLON -> : [165:19]
        |       |   |   `--SLIST -> SLIST [166:17]
        |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [166:17]
        |       |   |       |   |--MODIFIERS -> MODIFIERS [166:17]
        |       |   |       |   |--TYPE -> TYPE [166:17]
        |       |   |       |   |   `--LITERAL_INT -> int [166:17]
        |       |   |       |   `--IDENT -> b [166:21]
        |       |   |       `--SEMI -> ; [166:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [168:13]
        |       |   |   `--LITERAL_DEFAULT -> default [168:13]
        |       |   |       `--COLON -> : [168:20]
        |       |   `--RCURLY -> } [169:9]
        |       `--RCURLY -> } [170:5]
        |--METHOD_DEF -> METHOD_DEF [172:5]
        |   |--MODIFIERS -> MODIFIERS [172:5]
        |   |   `--LITERAL_PUBLIC -> public [172:5]
        |   |--TYPE -> TYPE [172:12]
        |   |   `--LITERAL_VOID -> void [172:12]
        |   |--IDENT -> foo6 [172:17]
        |   |--LPAREN -> ( [172:21]
        |   |--PARAMETERS -> PARAMETERS [172:22]
        |   |--RPAREN -> ) [172:22]
        |   `--SLIST -> { [172:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [173:9]
        |       |   |--MODIFIERS -> MODIFIERS [173:9]
        |       |   |--TYPE -> TYPE [173:9]
        |       |   |   `--LITERAL_INT -> int [173:9]
        |       |   |--IDENT -> a [173:13]
        |       |   `--ASSIGN -> = [173:15]
        |       |       `--EXPR -> EXPR [173:17]
        |       |           `--NUM_INT -> 1 [173:17]
        |       |--SEMI -> ; [173:18]
        |       |--LITERAL_SWITCH -> switch [174:9]
        |       |   |--LPAREN -> ( [174:16]
        |       |   |--EXPR -> EXPR [174:17]
        |       |   |   `--IDENT -> a [174:17]
        |       |   |--RPAREN -> ) [174:18]
        |       |   |--LCURLY -> { [174:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [175:13]
        |       |   |   |--LITERAL_CASE -> case [175:13]
        |       |   |   |   |--EXPR -> EXPR [175:18]
        |       |   |   |   |   `--NUM_INT -> 1 [175:18]
        |       |   |   |   `--COLON -> : [175:19]
        |       |   |   `--SLIST -> SLIST [176:17]
        |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [176:17]
        |       |   |       |   |--MODIFIERS -> MODIFIERS [176:17]
        |       |   |       |   |--TYPE -> TYPE [176:17]
        |       |   |       |   |   `--LITERAL_INT -> int [176:17]
        |       |   |       |   `--IDENT -> b [176:21]
        |       |   |       `--SEMI -> ; [176:22]
        |       |   |--CASE_GROUP -> CASE_GROUP [178:13]
        |       |   |   `--LITERAL_DEFAULT -> default [178:13]
        |       |   |       `--COLON -> : [178:20]
        |       |   `--RCURLY -> } [179:9]
        |       `--RCURLY -> } [180:5]
        |--METHOD_DEF -> METHOD_DEF [182:5]
        |   |--MODIFIERS -> MODIFIERS [182:5]
        |   |   `--LITERAL_PUBLIC -> public [182:5]
        |   |--TYPE -> TYPE [182:12]
        |   |   `--LITERAL_VOID -> void [182:12]
        |   |--IDENT -> foo7 [182:17]
        |   |--LPAREN -> ( [182:21]
        |   |--PARAMETERS -> PARAMETERS [182:22]
        |   |--RPAREN -> ) [182:22]
        |   `--SLIST -> { [182:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [183:9]
        |       |   |--MODIFIERS -> MODIFIERS [183:9]
        |       |   |--TYPE -> TYPE [183:9]
        |       |   |   `--LITERAL_INT -> int [183:9]
        |       |   |--IDENT -> a [183:13]
        |       |   `--ASSIGN -> = [183:15]
        |       |       `--EXPR -> EXPR [183:17]
        |       |           `--NUM_INT -> 2 [183:17]
        |       |--SEMI -> ; [183:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [184:9]
        |       |   |--MODIFIERS -> MODIFIERS [184:9]
        |       |   |--TYPE -> TYPE [184:9]
        |       |   |   `--IDENT -> String [184:9]
        |       |   |--IDENT -> s [184:16]
        |       |   `--ASSIGN -> = [184:18]
        |       |       `--EXPR -> EXPR [184:20]
        |       |           `--STRING_LITERAL -> "" [184:20]
        |       |--SEMI -> ; [184:22]
        |       |--LITERAL_SWITCH -> switch [185:9]
        |       |   |--LPAREN -> ( [185:16]
        |       |   |--EXPR -> EXPR [185:17]
        |       |   |   `--IDENT -> a [185:17]
        |       |   |--RPAREN -> ) [185:18]
        |       |   |--LCURLY -> { [185:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [189:13]
        |       |   |   |--LITERAL_CASE -> case [189:13]
        |       |   |   |   |--EXPR -> EXPR [189:18]
        |       |   |   |   |   `--NUM_INT -> 1 [189:18]
        |       |   |   |   `--COLON -> : [189:19]
        |       |   |   |--LITERAL_CASE -> case [190:13]
        |       |   |   |   |--EXPR -> EXPR [190:18]
        |       |   |   |   |   `--NUM_INT -> 2 [190:18]
        |       |   |   |   `--COLON -> : [190:19]
        |       |   |   `--SLIST -> SLIST [193:21]
        |       |   |       |--EXPR -> EXPR [193:21]
        |       |   |       |   `--METHOD_CALL -> ( [193:21]
        |       |   |       |       |--IDENT -> foo1 [193:17]
        |       |   |       |       |--ELIST -> ELIST [193:22]
        |       |   |       |       `--RPAREN -> ) [193:22]
        |       |   |       `--SEMI -> ; [193:23]
        |       |   |--CASE_GROUP -> CASE_GROUP [195:13]
        |       |   |   |--LITERAL_CASE -> case [195:13]
        |       |   |   |   |--EXPR -> EXPR [195:18]
        |       |   |   |   |   `--NUM_INT -> 3 [195:18]
        |       |   |   |   `--COLON -> : [195:19]
        |       |   |   |--LITERAL_CASE -> case [199:13]
        |       |   |   |   |--EXPR -> EXPR [199:18]
        |       |   |   |   |   `--NUM_INT -> 4 [199:18]
        |       |   |   |   `--COLON -> : [199:19]
        |       |   |   |--LITERAL_CASE -> case [201:13]
        |       |   |   |   |--EXPR -> EXPR [201:18]
        |       |   |   |   |   `--NUM_INT -> 5 [201:18]
        |       |   |   |   `--COLON -> : [201:19]
        |       |   |   `--SLIST -> SLIST [202:49]
        |       |   |       |--EXPR -> EXPR [202:49]
        |       |   |       |   `--METHOD_CALL -> ( [202:49]
        |       |   |       |       |--DOT -> . [202:40]
        |       |   |       |       |   |--METHOD_CALL -> ( [202:38]
        |       |   |       |       |   |   |--DOT -> . [202:29]
        |       |   |       |       |   |   |   |--METHOD_CALL -> ( [202:27]
        |       |   |       |       |   |   |   |   |--DOT -> . [202:18]
        |       |   |       |       |   |   |   |   |   |--IDENT -> s [202:17]
        |       |   |       |       |   |   |   |   |   `--IDENT -> toString [202:19]
        |       |   |       |       |   |   |   |   |--ELIST -> ELIST [202:28]
        |       |   |       |       |   |   |   |   `--RPAREN -> ) [202:28]
        |       |   |       |       |   |   |   `--IDENT -> toString [202:30]
        |       |   |       |       |   |   |--ELIST -> ELIST [202:39]
        |       |   |       |       |   |   `--RPAREN -> ) [202:39]
        |       |   |       |       |   `--IDENT -> toString [202:41]
        |       |   |       |       |--ELIST -> ELIST [202:50]
        |       |   |       |       `--RPAREN -> ) [202:50]
        |       |   |       `--SEMI -> ; [202:51]
        |       |   |--CASE_GROUP -> CASE_GROUP [206:13]
        |       |   |   `--LITERAL_DEFAULT -> default [206:13]
        |       |   |       `--COLON -> : [206:20]
        |       |   `--RCURLY -> } [207:9]
        |       `--RCURLY -> } [208:5]
        |--METHOD_DEF -> METHOD_DEF [210:5]
        |   |--MODIFIERS -> MODIFIERS [210:5]
        |   |   `--LITERAL_PUBLIC -> public [210:5]
        |   |--TYPE -> TYPE [210:12]
        |   |   `--LITERAL_VOID -> void [210:12]
        |   |--IDENT -> foo8 [210:17]
        |   |--LPAREN -> ( [210:21]
        |   |--PARAMETERS -> PARAMETERS [210:22]
        |   |--RPAREN -> ) [210:22]
        |   `--SLIST -> { [210:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [211:9]
        |       |   |--MODIFIERS -> MODIFIERS [211:9]
        |       |   |--TYPE -> TYPE [211:9]
        |       |   |   `--LITERAL_INT -> int [211:9]
        |       |   |--IDENT -> a [211:13]
        |       |   `--ASSIGN -> = [211:15]
        |       |       `--EXPR -> EXPR [211:17]
        |       |           `--NUM_INT -> 2 [211:17]
        |       |--SEMI -> ; [211:18]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [212:9]
        |       |   |--MODIFIERS -> MODIFIERS [212:9]
        |       |   |--TYPE -> TYPE [212:9]
        |       |   |   `--IDENT -> String [212:9]
        |       |   |--IDENT -> s [212:16]
        |       |   `--ASSIGN -> = [212:18]
        |       |       `--EXPR -> EXPR [212:20]
        |       |           `--STRING_LITERAL -> "" [212:20]
        |       |--SEMI -> ; [212:22]
        |       |--LITERAL_SWITCH -> switch [213:9]
        |       |   |--LPAREN -> ( [213:16]
        |       |   |--EXPR -> EXPR [213:17]
        |       |   |   `--IDENT -> a [213:17]
        |       |   |--RPAREN -> ) [213:18]
        |       |   |--LCURLY -> { [213:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [217:13]
        |       |   |   |--LITERAL_CASE -> case [217:13]
        |       |   |   |   |--EXPR -> EXPR [217:18]
        |       |   |   |   |   `--NUM_INT -> 1 [217:18]
        |       |   |   |   `--COLON -> : [217:19]
        |       |   |   |--LITERAL_CASE -> case [218:13]
        |       |   |   |   |--EXPR -> EXPR [218:18]
        |       |   |   |   |   `--NUM_INT -> 2 [218:18]
        |       |   |   |   `--COLON -> : [218:19]
        |       |   |   `--SLIST -> SLIST [221:21]
        |       |   |       |--EXPR -> EXPR [221:21]
        |       |   |       |   `--METHOD_CALL -> ( [221:21]
        |       |   |       |       |--IDENT -> foo1 [221:17]
        |       |   |       |       |--ELIST -> ELIST [221:22]
        |       |   |       |       `--RPAREN -> ) [221:22]
        |       |   |       `--SEMI -> ; [221:23]
        |       |   |--CASE_GROUP -> CASE_GROUP [223:13]
        |       |   |   |--LITERAL_CASE -> case [223:13]
        |       |   |   |   |--EXPR -> EXPR [223:18]
        |       |   |   |   |   `--NUM_INT -> 3 [223:18]
        |       |   |   |   `--COLON -> : [223:19]
        |       |   |   `--SLIST -> SLIST [226:49]
        |       |   |       |--EXPR -> EXPR [226:49]
        |       |   |       |   `--METHOD_CALL -> ( [226:49]
        |       |   |       |       |--DOT -> . [226:40]
        |       |   |       |       |   |--METHOD_CALL -> ( [226:38]
        |       |   |       |       |   |   |--DOT -> . [226:29]
        |       |   |       |       |   |   |   |--METHOD_CALL -> ( [226:27]
        |       |   |       |       |   |   |   |   |--DOT -> . [226:18]
        |       |   |       |       |   |   |   |   |   |--IDENT -> s [226:17]
        |       |   |       |       |   |   |   |   |   `--IDENT -> toString [226:19]
        |       |   |       |       |   |   |   |   |--ELIST -> ELIST [226:28]
        |       |   |       |       |   |   |   |   `--RPAREN -> ) [226:28]
        |       |   |       |       |   |   |   `--IDENT -> toString [226:30]
        |       |   |       |       |   |   |--ELIST -> ELIST [226:39]
        |       |   |       |       |   |   `--RPAREN -> ) [226:39]
        |       |   |       |       |   `--IDENT -> toString [226:41]
        |       |   |       |       |--ELIST -> ELIST [226:50]
        |       |   |       |       `--RPAREN -> ) [226:50]
        |       |   |       `--SEMI -> ; [226:51]
        |       |   |--CASE_GROUP -> CASE_GROUP [228:13]
        |       |   |   |--LITERAL_CASE -> case [228:13]
        |       |   |   |   |--EXPR -> EXPR [228:18]
        |       |   |   |   |   `--NUM_INT -> 4 [228:18]
        |       |   |   |   `--COLON -> : [228:19]
        |       |   |   `--LITERAL_DEFAULT -> default [230:13]
        |       |   |       `--COLON -> : [230:20]
        |       |   `--RCURLY -> } [231:9]
        |       `--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 -> foo9 [234:17]
        |   |--LPAREN -> ( [234:21]
        |   |--PARAMETERS -> PARAMETERS [234:22]
        |   |--RPAREN -> ) [234:22]
        |   `--SLIST -> { [234:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [235:9]
        |       |   |--MODIFIERS -> MODIFIERS [235:9]
        |       |   |--TYPE -> TYPE [235:9]
        |       |   |   `--LITERAL_INT -> int [235:9]
        |       |   |--IDENT -> a [235:13]
        |       |   `--ASSIGN -> = [235:15]
        |       |       `--EXPR -> EXPR [235:17]
        |       |           `--NUM_INT -> 5 [235:17]
        |       |--SEMI -> ; [235:18]
        |       |--LITERAL_SWITCH -> switch [236:9]
        |       |   |--LPAREN -> ( [236:16]
        |       |   |--EXPR -> EXPR [236:17]
        |       |   |   `--IDENT -> a [236:17]
        |       |   |--RPAREN -> ) [236:18]
        |       |   |--LCURLY -> { [236:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [237:13]
        |       |   |   |--LITERAL_CASE -> case [237:13]
        |       |   |   |   |--EXPR -> EXPR [237:18]
        |       |   |   |   |   `--NUM_INT -> 1 [237:18]
        |       |   |   |   `--COLON -> : [237:19]
        |       |   |   `--LITERAL_CASE -> case [238:13]
        |       |   |       |--EXPR -> EXPR [238:18]
        |       |   |       |   `--NUM_INT -> 2 [238:18]
        |       |   |       `--COLON -> : [238:19]
        |       |   `--RCURLY -> } [240:9]
        |       `--RCURLY -> } [241:5]
        |--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 -> foo10 [243:17]
        |   |--LPAREN -> ( [243:22]
        |   |--PARAMETERS -> PARAMETERS [243:23]
        |   |--RPAREN -> ) [243:23]
        |   `--SLIST -> { [243:25]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [244:9]
        |       |   |--MODIFIERS -> MODIFIERS [244:9]
        |       |   |--TYPE -> TYPE [244:9]
        |       |   |   `--LITERAL_INT -> int [244:9]
        |       |   |--IDENT -> a [244:13]
        |       |   `--ASSIGN -> = [244:15]
        |       |       `--EXPR -> EXPR [244:17]
        |       |           `--NUM_INT -> 5 [244:17]
        |       |--SEMI -> ; [244:18]
        |       |--LITERAL_SWITCH -> switch [245:9]
        |       |   |--LPAREN -> ( [245:16]
        |       |   |--EXPR -> EXPR [245:17]
        |       |   |   `--IDENT -> a [245:17]
        |       |   |--RPAREN -> ) [245:18]
        |       |   |--LCURLY -> { [245:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [246:13]
        |       |   |   |--LITERAL_CASE -> case [246:13]
        |       |   |   |   |--EXPR -> EXPR [246:18]
        |       |   |   |   |   `--NUM_INT -> 1 [246:18]
        |       |   |   |   `--COLON -> : [246:19]
        |       |   |   `--LITERAL_DEFAULT -> default [247:13]
        |       |   |       `--COLON -> : [247:20]
        |       |   `--RCURLY -> } [249:9]
        |       `--RCURLY -> } [250:5]
        |--METHOD_DEF -> METHOD_DEF [252:5]
        |   |--MODIFIERS -> MODIFIERS [252:5]
        |   |   `--LITERAL_PUBLIC -> public [252:5]
        |   |--TYPE -> TYPE [252:12]
        |   |   `--LITERAL_VOID -> void [252:12]
        |   |--IDENT -> foo11 [252:17]
        |   |--LPAREN -> ( [252:22]
        |   |--PARAMETERS -> PARAMETERS [252:23]
        |   |--RPAREN -> ) [252:23]
        |   `--SLIST -> { [252:25]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [253:9]
        |       |   |--MODIFIERS -> MODIFIERS [253:9]
        |       |   |--TYPE -> TYPE [253:9]
        |       |   |   `--LITERAL_INT -> int [253:9]
        |       |   |--IDENT -> a [253:13]
        |       |   `--ASSIGN -> = [253:15]
        |       |       `--EXPR -> EXPR [253:17]
        |       |           `--NUM_INT -> 5 [253:17]
        |       |--SEMI -> ; [253:18]
        |       |--LITERAL_SWITCH -> switch [254:9]
        |       |   |--LPAREN -> ( [254:16]
        |       |   |--EXPR -> EXPR [254:17]
        |       |   |   `--IDENT -> a [254:17]
        |       |   |--RPAREN -> ) [254:18]
        |       |   |--LCURLY -> { [254:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [255:13]
        |       |   |   |--LITERAL_CASE -> case [255:13]
        |       |   |   |   |--EXPR -> EXPR [255:18]
        |       |   |   |   |   `--NUM_INT -> 1 [255:18]
        |       |   |   |   `--COLON -> : [255:19]
        |       |   |   `--LITERAL_CASE -> case [256:13]
        |       |   |       |--EXPR -> EXPR [256:18]
        |       |   |       |   `--NUM_INT -> 2 [256:18]
        |       |   |       `--COLON -> : [256:19]
        |       |   `--RCURLY -> } [258:9]
        |       `--RCURLY -> } [259:5]
        |--METHOD_DEF -> METHOD_DEF [261:5]
        |   |--MODIFIERS -> MODIFIERS [261:5]
        |   |   `--LITERAL_PUBLIC -> public [261:5]
        |   |--TYPE -> TYPE [261:12]
        |   |   `--LITERAL_VOID -> void [261:12]
        |   |--IDENT -> foo12 [261:17]
        |   |--LPAREN -> ( [261:22]
        |   |--PARAMETERS -> PARAMETERS [261:23]
        |   |--RPAREN -> ) [261:23]
        |   `--SLIST -> { [261:25]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [262:9]
        |       |   |--MODIFIERS -> MODIFIERS [262:9]
        |       |   |--TYPE -> TYPE [262:9]
        |       |   |   `--LITERAL_INT -> int [262:9]
        |       |   |--IDENT -> a [262:13]
        |       |   `--ASSIGN -> = [262:15]
        |       |       `--EXPR -> EXPR [262:17]
        |       |           `--NUM_INT -> 5 [262:17]
        |       |--SEMI -> ; [262:18]
        |       |--LITERAL_SWITCH -> switch [263:9]
        |       |   |--LPAREN -> ( [263:16]
        |       |   |--EXPR -> EXPR [263:17]
        |       |   |   `--IDENT -> a [263:17]
        |       |   |--RPAREN -> ) [263:18]
        |       |   |--LCURLY -> { [263:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [265:13]
        |       |   |   `--LITERAL_CASE -> case [265:13]
        |       |   |       |--EXPR -> EXPR [265:18]
        |       |   |       |   `--NUM_INT -> 1 [265:18]
        |       |   |       `--COLON -> : [265:19]
        |       |   `--RCURLY -> } [266:9]
        |       `--RCURLY -> } [267:5]
        `--RCURLY -> } [268:1]
