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