PACKAGE_DEF -> package [2:0]
|--ANNOTATIONS -> ANNOTATIONS [2:47]
|--DOT -> . [2:47]
|   |--DOT -> . [2:39]
|   |   |--DOT -> . [2:28]
|   |   |   |--DOT -> . [2:22]
|   |   |   |   |--DOT -> . [2:11]
|   |   |   |   |   |--IDENT -> com [2:8]
|   |   |   |   |   `--IDENT -> puppycrawl [2:12]
|   |   |   |   `--IDENT -> tools [2:23]
|   |   |   `--IDENT -> checkstyle [2:29]
|   |   `--IDENT -> grammar [2:40]
|   `--IDENT -> java14 [2:48]
`--SEMI -> ; [2:54]
STATIC_IMPORT -> import [4:0]
|--LITERAL_STATIC -> static [4:7]
|--DOT -> . [4:31]
|   |--DOT -> . [4:23]
|   |   |--DOT -> . [4:18]
|   |   |   |--IDENT -> java [4:14]
|   |   |   `--IDENT -> time [4:19]
|   |   `--IDENT -> Instant [4:24]
|   `--STAR -> * [4:32]
`--SEMI -> ; [4:33]
IMPORT -> import [6:0]
|--DOT -> . [6:16]
|   |--DOT -> . [6:11]
|   |   |--IDENT -> java [6:7]
|   |   `--IDENT -> time [6:12]
|   `--IDENT -> Instant [6:17]
`--SEMI -> ; [6:24]
IMPORT -> import [7:0]
|--DOT -> . [7:16]
|   |--DOT -> . [7:11]
|   |   |--IDENT -> java [7:7]
|   |   `--IDENT -> util [7:12]
|   `--IDENT -> Arrays [7:17]
`--SEMI -> ; [7:23]
IMPORT -> import [8:0]
|--DOT -> . [8:16]
|   |--DOT -> . [8:11]
|   |   |--IDENT -> java [8:7]
|   |   `--IDENT -> util [8:12]
|   `--IDENT -> EnumSet [8:17]
`--SEMI -> ; [8:24]
IMPORT -> import [9:0]
|--DOT -> . [9:16]
|   |--DOT -> . [9:11]
|   |   |--IDENT -> java [9:7]
|   |   `--IDENT -> util [9:12]
|   `--IDENT -> Set [9:17]
`--SEMI -> ; [9:20]
IMPORT -> import [10:0]
|--DOT -> . [10:25]
|   |--DOT -> . [10:16]
|   |   |--DOT -> . [10:11]
|   |   |   |--IDENT -> java [10:7]
|   |   |   `--IDENT -> util [10:12]
|   |   `--IDENT -> function [10:17]
|   `--IDENT -> IntConsumer [10:26]
`--SEMI -> ; [10:37]
IMPORT -> import [11:0]
|--DOT -> . [11:25]
|   |--DOT -> . [11:16]
|   |   |--DOT -> . [11:11]
|   |   |   |--IDENT -> java [11:7]
|   |   |   `--IDENT -> util [11:12]
|   |   `--IDENT -> function [11:17]
|   `--IDENT -> Supplier [11:26]
`--SEMI -> ; [11:34]
CLASS_DEF -> CLASS_DEF [13:0]
|--MODIFIERS -> MODIFIERS [13:0]
|   `--LITERAL_PUBLIC -> public [13:0]
|--LITERAL_CLASS -> class [13:7]
|--IDENT -> InputJava14SwitchExpression [13:13]
`--OBJBLOCK -> OBJBLOCK [13:41]
    |--LCURLY -> { [13:41]
    |--CLASS_DEF -> CLASS_DEF [15:4]
    |   |--MODIFIERS -> MODIFIERS [15:4]
    |   |   `--LITERAL_STATIC -> static [15:4]
    |   |--LITERAL_CLASS -> class [15:11]
    |   |--IDENT -> HardToParse [15:17]
    |   `--OBJBLOCK -> OBJBLOCK [15:29]
    |       |--LCURLY -> { [15:29]
    |       |--METHOD_DEF -> METHOD_DEF [16:8]
    |       |   |--MODIFIERS -> MODIFIERS [16:8]
    |       |   |--TYPE -> TYPE [16:8]
    |       |   |   `--LITERAL_VOID -> void [16:8]
    |       |   |--IDENT -> foo [16:13]
    |       |   |--LPAREN -> ( [16:16]
    |       |   |--PARAMETERS -> PARAMETERS [16:17]
    |       |   |--RPAREN -> ) [16:17]
    |       |   `--SLIST -> { [16:19]
    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [17:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [17:12]
    |       |       |   |--TYPE -> TYPE [17:12]
    |       |       |   |   `--IDENT -> Instant [17:12]
    |       |       |   `--IDENT -> Ascii [17:20]
    |       |       |--SEMI -> ; [17:25]
    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [18:16]
    |       |       |   |--MODIFIERS -> MODIFIERS [18:16]
    |       |       |   |--TYPE -> TYPE [18:16]
    |       |       |   |   `--ARRAY_DECLARATOR -> [ [18:16]
    |       |       |   |       |--LITERAL_BYTE -> byte [18:12]
    |       |       |   |       `--RBRACK -> ] [18:17]
    |       |       |   |--IDENT -> decodabet [18:19]
    |       |       |   `--ASSIGN -> = [18:29]
    |       |       |       `--EXPR -> EXPR [18:31]
    |       |       |           `--LITERAL_NEW -> new [18:31]
    |       |       |               |--LITERAL_BYTE -> byte [18:35]
    |       |       |               `--ARRAY_DECLARATOR -> [ [18:39]
    |       |       |                   |--EXPR -> EXPR [18:40]
    |       |       |                   |   `--NUM_INT -> 1 [18:40]
    |       |       |                   `--RBRACK -> ] [18:41]
    |       |       |--SEMI -> ; [18:42]
    |       |       |--EXPR -> EXPR [19:23]
    |       |       |   `--METHOD_CALL -> ( [19:23]
    |       |       |       |--DOT -> . [19:18]
    |       |       |       |   |--IDENT -> Arrays [19:12]
    |       |       |       |   `--IDENT -> fill [19:19]
    |       |       |       |--ELIST -> ELIST [19:24]
    |       |       |       |   |--EXPR -> EXPR [19:24]
    |       |       |       |   |   `--IDENT -> decodabet [19:24]
    |       |       |       |   |--COMMA -> , [19:33]
    |       |       |       |   `--EXPR -> EXPR [19:35]
    |       |       |       |       `--TYPECAST -> ( [19:35]
    |       |       |       |           |--TYPE -> TYPE [19:36]
    |       |       |       |           |   `--LITERAL_BYTE -> byte [19:36]
    |       |       |       |           |--RPAREN -> ) [19:40]
    |       |       |       |           `--UNARY_MINUS -> - [19:42]
    |       |       |       |               `--NUM_INT -> 1 [19:43]
    |       |       |       `--RPAREN -> ) [19:44]
    |       |       |--SEMI -> ; [19:45]
    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [20:16]
    |       |       |   |--MODIFIERS -> MODIFIERS [20:16]
    |       |       |   |--TYPE -> TYPE [20:16]
    |       |       |   |   `--ARRAY_DECLARATOR -> [ [20:16]
    |       |       |   |       |--LITERAL_CHAR -> char [20:12]
    |       |       |   |       `--RBRACK -> ] [20:17]
    |       |       |   |--IDENT -> chars [20:19]
    |       |       |   `--ASSIGN -> = [20:25]
    |       |       |       `--ARRAY_INIT -> { [20:27]
    |       |       |           |--EXPR -> EXPR [20:28]
    |       |       |           |   `--CHAR_LITERAL -> 'c' [20:28]
    |       |       |           |--COMMA -> , [20:31]
    |       |       |           |--EXPR -> EXPR [20:32]
    |       |       |           |   `--CHAR_LITERAL -> 'h' [20:32]
    |       |       |           |--COMMA -> , [20:35]
    |       |       |           |--EXPR -> EXPR [20:36]
    |       |       |           |   `--CHAR_LITERAL -> 'a' [20:36]
    |       |       |           |--COMMA -> , [20:39]
    |       |       |           |--EXPR -> EXPR [20:40]
    |       |       |           |   `--CHAR_LITERAL -> 'r' [20:40]
    |       |       |           |--COMMA -> , [20:43]
    |       |       |           |--EXPR -> EXPR [20:44]
    |       |       |           |   `--CHAR_LITERAL -> 's' [20:44]
    |       |       |           `--RCURLY -> } [20:47]
    |       |       |--SEMI -> ; [20:48]
    |       |       |--LITERAL_FOR -> for [21:12]
    |       |       |   |--LPAREN -> ( [21:16]
    |       |       |   |--FOR_INIT -> FOR_INIT [22:20]
    |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [22:20]
    |       |       |   |       |--MODIFIERS -> MODIFIERS [22:20]
    |       |       |   |       |--TYPE -> TYPE [22:20]
    |       |       |   |       |   `--LITERAL_INT -> int [22:20]
    |       |       |   |       |--IDENT -> i [22:24]
    |       |       |   |       `--ASSIGN -> = [22:26]
    |       |       |   |           `--EXPR -> EXPR [22:28]
    |       |       |   |               `--NUM_INT -> 0 [22:28]
    |       |       |   |--SEMI -> ; [22:29]
    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [23:22]
    |       |       |   |   `--EXPR -> EXPR [23:22]
    |       |       |   |       `--LT -> < [23:22]
    |       |       |   |           |--IDENT -> i [23:20]
    |       |       |   |           `--DOT -> . [23:29]
    |       |       |   |               |--IDENT -> chars [23:24]
    |       |       |   |               `--IDENT -> length [23:30]
    |       |       |   |--SEMI -> ; [23:36]
    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [23:39]
    |       |       |   |   `--ELIST -> ELIST [23:39]
    |       |       |   |       `--EXPR -> EXPR [23:39]
    |       |       |   |           `--POST_INC -> ++ [23:39]
    |       |       |   |               `--IDENT -> i [23:38]
    |       |       |   |--RPAREN -> ) [23:41]
    |       |       |   `--SLIST -> { [23:43]
    |       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [24:16]
    |       |       |       |   |--MODIFIERS -> MODIFIERS [24:16]
    |       |       |       |   |--TYPE -> TYPE [24:16]
    |       |       |       |   |   `--LITERAL_CHAR -> char [24:16]
    |       |       |       |   |--IDENT -> c [24:21]
    |       |       |       |   `--ASSIGN -> = [24:23]
    |       |       |       |       `--EXPR -> EXPR [24:30]
    |       |       |       |           `--INDEX_OP -> [ [24:30]
    |       |       |       |               |--IDENT -> chars [24:25]
    |       |       |       |               |--EXPR -> EXPR [24:31]
    |       |       |       |               |   `--IDENT -> i [24:31]
    |       |       |       |               `--RBRACK -> ] [24:32]
    |       |       |       |--SEMI -> ; [24:33]
    |       |       |       |--EXPR -> EXPR [25:29]
    |       |       |       |   `--ASSIGN -> = [25:29]
    |       |       |       |       |--INDEX_OP -> [ [25:25]
    |       |       |       |       |   |--IDENT -> decodabet [25:16]
    |       |       |       |       |   |--EXPR -> EXPR [25:26]
    |       |       |       |       |   |   `--IDENT -> c [25:26]
    |       |       |       |       |   `--RBRACK -> ] [25:27]
    |       |       |       |       `--TYPECAST -> ( [25:31]
    |       |       |       |           |--TYPE -> TYPE [25:32]
    |       |       |       |           |   `--LITERAL_BYTE -> byte [25:32]
    |       |       |       |           |--RPAREN -> ) [25:36]
    |       |       |       |           `--IDENT -> i [25:38]
    |       |       |       |--SEMI -> ; [25:39]
    |       |       |       `--RCURLY -> } [26:12]
    |       |       `--RCURLY -> } [27:8]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [28:8]
    |       |   |--MODIFIERS -> MODIFIERS [28:8]
    |       |   |--TYPE -> TYPE [28:8]
    |       |   |   `--IDENT -> IntConsumer [28:8]
    |       |   |--IDENT -> consumer [28:20]
    |       |   |--ASSIGN -> = [28:29]
    |       |   |   `--EXPR -> EXPR [28:31]
    |       |   |       `--TYPECAST -> ( [28:31]
    |       |   |           |--TYPE -> TYPE [28:32]
    |       |   |           |   `--IDENT -> IntConsumer [28:32]
    |       |   |           |--RPAREN -> ) [28:43]
    |       |   |           `--LAMBDA -> -> [28:47]
    |       |   |               |--IDENT -> i [28:45]
    |       |   |               `--SLIST -> { [28:50]
    |       |   |                   `--RCURLY -> } [29:8]
    |       |   `--SEMI -> ; [29:9]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
    |       |   |--MODIFIERS -> MODIFIERS [31:8]
    |       |   |   `--LITERAL_STATIC -> static [31:8]
    |       |   |--TYPE -> TYPE [31:15]
    |       |   |   `--IDENT -> String [31:15]
    |       |   |--IDENT -> yield [31:22]
    |       |   |--ASSIGN -> = [31:28]
    |       |   |   `--EXPR -> EXPR [31:30]
    |       |   |       `--STRING_LITERAL -> "yield" [31:30]
    |       |   `--SEMI -> ; [31:37]
    |       |--CLASS_DEF -> CLASS_DEF [33:8]
    |       |   |--MODIFIERS -> MODIFIERS [33:8]
    |       |   |--LITERAL_CLASS -> class [33:8]
    |       |   |--IDENT -> yieldClass [33:14]
    |       |   `--OBJBLOCK -> OBJBLOCK [33:24]
    |       |       |--LCURLY -> { [33:24]
    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [34:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [34:12]
    |       |       |   |--TYPE -> TYPE [34:12]
    |       |       |   |   `--LITERAL_INT -> int [34:12]
    |       |       |   |--IDENT -> yield [34:16]
    |       |       |   |--ASSIGN -> = [34:22]
    |       |       |   |   `--EXPR -> EXPR [34:24]
    |       |       |   |       `--NUM_INT -> 6 [34:24]
    |       |       |   `--SEMI -> ; [34:25]
    |       |       |--METHOD_DEF -> METHOD_DEF [36:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [36:12]
    |       |       |   |   `--LITERAL_PUBLIC -> public [36:12]
    |       |       |   |--TYPE -> TYPE [36:19]
    |       |       |   |   `--LITERAL_VOID -> void [36:19]
    |       |       |   |--IDENT -> yield [36:24]
    |       |       |   |--LPAREN -> ( [36:29]
    |       |       |   |--PARAMETERS -> PARAMETERS [36:30]
    |       |       |   |--RPAREN -> ) [36:30]
    |       |       |   `--SLIST -> { [36:31]
    |       |       |       `--RCURLY -> } [38:12]
    |       |       `--RCURLY -> } [39:8]
    |       `--RCURLY -> } [41:4]
    |--ENUM_DEF -> ENUM_DEF [43:4]
    |   |--MODIFIERS -> MODIFIERS [43:4]
    |   |--ENUM -> enum [43:4]
    |   |--IDENT -> Day [43:9]
    |   `--OBJBLOCK -> OBJBLOCK [43:13]
    |       |--LCURLY -> { [43:13]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [44:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [44:8]
    |       |   `--IDENT -> MON [44:8]
    |       |--COMMA -> , [44:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [45:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [45:8]
    |       |   `--IDENT -> TUE [45:8]
    |       |--COMMA -> , [45:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [46:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [46:8]
    |       |   `--IDENT -> WED [46:8]
    |       |--COMMA -> , [46:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [47:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [47:8]
    |       |   `--IDENT -> THU [47:8]
    |       |--COMMA -> , [47:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [48:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [48:8]
    |       |   `--IDENT -> FRI [48:8]
    |       |--COMMA -> , [48:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [49:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [49:8]
    |       |   `--IDENT -> SAT [49:8]
    |       |--COMMA -> , [49:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [50:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [50:8]
    |       |   `--IDENT -> SUN [50:8]
    |       |--COMMA -> , [50:11]
    |       `--RCURLY -> } [51:4]
    |--METHOD_DEF -> METHOD_DEF [53:4]
    |   |--MODIFIERS -> MODIFIERS [53:4]
    |   |--TYPE -> TYPE [53:4]
    |   |   `--IDENT -> String [53:4]
    |   |--IDENT -> whatIsToday [53:11]
    |   |--LPAREN -> ( [53:22]
    |   |--PARAMETERS -> PARAMETERS [53:23]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [53:23]
    |   |       |--MODIFIERS -> MODIFIERS [53:23]
    |   |       |--TYPE -> TYPE [53:23]
    |   |       |   `--IDENT -> Day [53:23]
    |   |       `--IDENT -> day [53:27]
    |   |--RPAREN -> ) [53:30]
    |   `--SLIST -> { [53:32]
    |       |--LITERAL_RETURN -> return [54:8]
    |       |   |--EXPR -> EXPR [54:15]
    |       |   |   `--LITERAL_SWITCH -> switch [54:15]
    |       |   |       |--LPAREN -> ( [54:22]
    |       |   |       |--EXPR -> EXPR [54:23]
    |       |   |       |   `--IDENT -> day [54:23]
    |       |   |       |--RPAREN -> ) [54:26]
    |       |   |       |--LCURLY -> { [54:28]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [55:12]
    |       |   |       |   |--LITERAL_CASE -> case [55:12]
    |       |   |       |   |   |--EXPR -> EXPR [55:17]
    |       |   |       |   |   |   `--IDENT -> SAT [55:17]
    |       |   |       |   |   |--COMMA -> , [55:20]
    |       |   |       |   |   `--EXPR -> EXPR [55:22]
    |       |   |       |   |       `--IDENT -> SUN [55:22]
    |       |   |       |   |--LAMBDA -> -> [55:26]
    |       |   |       |   |--EXPR -> EXPR [55:29]
    |       |   |       |   |   `--STRING_LITERAL -> "Weekend" [55:29]
    |       |   |       |   `--SEMI -> ; [55:38]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [56:12]
    |       |   |       |   |--LITERAL_CASE -> case [56:12]
    |       |   |       |   |   |--EXPR -> EXPR [56:17]
    |       |   |       |   |   |   `--IDENT -> MON [56:17]
    |       |   |       |   |   |--COMMA -> , [56:20]
    |       |   |       |   |   |--EXPR -> EXPR [56:22]
    |       |   |       |   |   |   `--IDENT -> TUE [56:22]
    |       |   |       |   |   |--COMMA -> , [56:25]
    |       |   |       |   |   |--EXPR -> EXPR [56:27]
    |       |   |       |   |   |   `--IDENT -> WED [56:27]
    |       |   |       |   |   |--COMMA -> , [56:30]
    |       |   |       |   |   |--EXPR -> EXPR [56:32]
    |       |   |       |   |   |   `--IDENT -> THU [56:32]
    |       |   |       |   |   |--COMMA -> , [56:35]
    |       |   |       |   |   `--EXPR -> EXPR [56:37]
    |       |   |       |   |       `--IDENT -> FRI [56:37]
    |       |   |       |   |--LAMBDA -> -> [56:41]
    |       |   |       |   |--EXPR -> EXPR [56:44]
    |       |   |       |   |   `--STRING_LITERAL -> "Working day" [56:44]
    |       |   |       |   `--SEMI -> ; [56:57]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [57:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [57:12]
    |       |   |       |   |--LAMBDA -> -> [57:20]
    |       |   |       |   `--LITERAL_THROW -> throw [57:23]
    |       |   |       |       |--EXPR -> EXPR [57:29]
    |       |   |       |       |   `--LITERAL_NEW -> new [57:29]
    |       |   |       |       |       |--IDENT -> IllegalArgumentException [57:33]
    |       |   |       |       |       |--LPAREN -> ( [57:57]
    |       |   |       |       |       |--ELIST -> ELIST [57:74]
    |       |   |       |       |       |   `--EXPR -> EXPR [57:74]
    |       |   |       |       |       |       `--PLUS -> + [57:74]
    |       |   |       |       |       |           |--STRING_LITERAL -> "Invalid day: " [57:58]
    |       |   |       |       |       |           `--METHOD_CALL -> ( [57:84]
    |       |   |       |       |       |               |--DOT -> . [57:79]
    |       |   |       |       |       |               |   |--IDENT -> day [57:76]
    |       |   |       |       |       |               |   `--IDENT -> name [57:80]
    |       |   |       |       |       |               |--ELIST -> ELIST [57:85]
    |       |   |       |       |       |               `--RPAREN -> ) [57:85]
    |       |   |       |       |       `--RPAREN -> ) [57:86]
    |       |   |       |       `--SEMI -> ; [57:87]
    |       |   |       `--RCURLY -> } [58:8]
    |       |   `--SEMI -> ; [58:9]
    |       `--RCURLY -> } [59:4]
    |--METHOD_DEF -> METHOD_DEF [61:4]
    |   |--MODIFIERS -> MODIFIERS [61:4]
    |   |--TYPE -> TYPE [61:4]
    |   |   |--IDENT -> Set [61:4]
    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [61:7]
    |   |       |--GENERIC_START -> < [61:7]
    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [61:8]
    |   |       |   `--IDENT -> Day [61:8]
    |   |       `--GENERIC_END -> > [61:11]
    |   |--IDENT -> days [61:13]
    |   |--LPAREN -> ( [61:17]
    |   |--PARAMETERS -> PARAMETERS [61:18]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [61:18]
    |   |       |--MODIFIERS -> MODIFIERS [61:18]
    |   |       |--TYPE -> TYPE [61:18]
    |   |       |   `--IDENT -> String [61:18]
    |   |       `--IDENT -> weekPart [61:25]
    |   |--RPAREN -> ) [61:33]
    |   `--SLIST -> { [61:35]
    |       |--LITERAL_RETURN -> return [62:8]
    |       |   |--EXPR -> EXPR [62:15]
    |       |   |   `--LITERAL_SWITCH -> switch [62:15]
    |       |   |       |--LPAREN -> ( [62:22]
    |       |   |       |--EXPR -> EXPR [62:23]
    |       |   |       |   `--IDENT -> weekPart [62:23]
    |       |   |       |--RPAREN -> ) [62:31]
    |       |   |       |--LCURLY -> { [62:33]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [63:12]
    |       |   |       |   |--LITERAL_CASE -> case [63:12]
    |       |   |       |   |   `--EXPR -> EXPR [63:17]
    |       |   |       |   |       `--STRING_LITERAL -> "Weekend" [63:17]
    |       |   |       |   |--LAMBDA -> -> [63:27]
    |       |   |       |   |--EXPR -> EXPR [63:40]
    |       |   |       |   |   `--METHOD_CALL -> ( [63:40]
    |       |   |       |   |       |--DOT -> . [63:37]
    |       |   |       |   |       |   |--IDENT -> EnumSet [63:30]
    |       |   |       |   |       |   `--IDENT -> of [63:38]
    |       |   |       |   |       |--ELIST -> ELIST [63:44]
    |       |   |       |   |       |   |--EXPR -> EXPR [63:44]
    |       |   |       |   |       |   |   `--DOT -> . [63:44]
    |       |   |       |   |       |   |       |--IDENT -> Day [63:41]
    |       |   |       |   |       |   |       `--IDENT -> SAT [63:45]
    |       |   |       |   |       |   |--COMMA -> , [63:48]
    |       |   |       |   |       |   `--EXPR -> EXPR [63:53]
    |       |   |       |   |       |       `--DOT -> . [63:53]
    |       |   |       |   |       |           |--IDENT -> Day [63:50]
    |       |   |       |   |       |           `--IDENT -> SUN [63:54]
    |       |   |       |   |       `--RPAREN -> ) [63:57]
    |       |   |       |   `--SEMI -> ; [63:58]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [64:12]
    |       |   |       |   |--LITERAL_CASE -> case [64:12]
    |       |   |       |   |   `--EXPR -> EXPR [64:17]
    |       |   |       |   |       `--STRING_LITERAL -> "Working day" [64:17]
    |       |   |       |   |--LAMBDA -> -> [64:31]
    |       |   |       |   |--EXPR -> EXPR [64:44]
    |       |   |       |   |   `--METHOD_CALL -> ( [64:44]
    |       |   |       |   |       |--DOT -> . [64:41]
    |       |   |       |   |       |   |--IDENT -> EnumSet [64:34]
    |       |   |       |   |       |   `--IDENT -> of [64:42]
    |       |   |       |   |       |--ELIST -> ELIST [64:48]
    |       |   |       |   |       |   |--EXPR -> EXPR [64:48]
    |       |   |       |   |       |   |   `--DOT -> . [64:48]
    |       |   |       |   |       |   |       |--IDENT -> Day [64:45]
    |       |   |       |   |       |   |       `--IDENT -> MON [64:49]
    |       |   |       |   |       |   |--COMMA -> , [64:52]
    |       |   |       |   |       |   |--EXPR -> EXPR [64:57]
    |       |   |       |   |       |   |   `--DOT -> . [64:57]
    |       |   |       |   |       |   |       |--IDENT -> Day [64:54]
    |       |   |       |   |       |   |       `--IDENT -> TUE [64:58]
    |       |   |       |   |       |   |--COMMA -> , [64:61]
    |       |   |       |   |       |   |--EXPR -> EXPR [64:66]
    |       |   |       |   |       |   |   `--DOT -> . [64:66]
    |       |   |       |   |       |   |       |--IDENT -> Day [64:63]
    |       |   |       |   |       |   |       `--IDENT -> WED [64:67]
    |       |   |       |   |       |   |--COMMA -> , [64:70]
    |       |   |       |   |       |   |--EXPR -> EXPR [64:75]
    |       |   |       |   |       |   |   `--DOT -> . [64:75]
    |       |   |       |   |       |   |       |--IDENT -> Day [64:72]
    |       |   |       |   |       |   |       `--IDENT -> THU [64:76]
    |       |   |       |   |       |   |--COMMA -> , [64:79]
    |       |   |       |   |       |   `--EXPR -> EXPR [64:84]
    |       |   |       |   |       |       `--DOT -> . [64:84]
    |       |   |       |   |       |           |--IDENT -> Day [64:81]
    |       |   |       |   |       |           `--IDENT -> FRI [64:85]
    |       |   |       |   |       `--RPAREN -> ) [64:88]
    |       |   |       |   `--SEMI -> ; [64:89]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [65:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [65:12]
    |       |   |       |   |--LAMBDA -> -> [65:20]
    |       |   |       |   `--LITERAL_THROW -> throw [65:23]
    |       |   |       |       |--EXPR -> EXPR [65:29]
    |       |   |       |       |   `--LITERAL_NEW -> new [65:29]
    |       |   |       |       |       |--IDENT -> IllegalArgumentException [65:33]
    |       |   |       |       |       |--LPAREN -> ( [65:57]
    |       |   |       |       |       |--ELIST -> ELIST [65:79]
    |       |   |       |       |       |   `--EXPR -> EXPR [65:79]
    |       |   |       |       |       |       `--PLUS -> + [65:79]
    |       |   |       |       |       |           |--STRING_LITERAL -> "Invalid weekPart: " [65:58]
    |       |   |       |       |       |           `--IDENT -> weekPart [65:81]
    |       |   |       |       |       `--RPAREN -> ) [65:89]
    |       |   |       |       `--SEMI -> ; [65:90]
    |       |   |       `--RCURLY -> } [66:8]
    |       |   `--SEMI -> ; [66:9]
    |       `--RCURLY -> } [67:4]
    |--METHOD_DEF -> METHOD_DEF [69:4]
    |   |--MODIFIERS -> MODIFIERS [69:4]
    |   |--TYPE -> TYPE [69:4]
    |   |   `--IDENT -> String [69:4]
    |   |--IDENT -> isDayNameLong [69:11]
    |   |--LPAREN -> ( [69:24]
    |   |--PARAMETERS -> PARAMETERS [69:25]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [69:25]
    |   |       |--MODIFIERS -> MODIFIERS [69:25]
    |   |       |--TYPE -> TYPE [69:25]
    |   |       |   `--IDENT -> Day [69:25]
    |   |       `--IDENT -> day [69:29]
    |   |--RPAREN -> ) [69:32]
    |   `--SLIST -> { [69:34]
    |       |--LITERAL_RETURN -> return [70:8]
    |       |   |--EXPR -> EXPR [75:14]
    |       |   |   `--QUESTION -> ? [75:14]
    |       |   |       |--GT -> > [75:10]
    |       |   |       |   |--LITERAL_SWITCH -> switch [70:15]
    |       |   |       |   |   |--LPAREN -> ( [70:22]
    |       |   |       |   |   |--EXPR -> EXPR [70:23]
    |       |   |       |   |   |   `--IDENT -> day [70:23]
    |       |   |       |   |   |--RPAREN -> ) [70:26]
    |       |   |       |   |   |--LCURLY -> { [70:28]
    |       |   |       |   |   |--SWITCH_RULE -> SWITCH_RULE [71:12]
    |       |   |       |   |   |   |--LITERAL_CASE -> case [71:12]
    |       |   |       |   |   |   |   |--EXPR -> EXPR [71:17]
    |       |   |       |   |   |   |   |   `--IDENT -> MON [71:17]
    |       |   |       |   |   |   |   |--COMMA -> , [71:20]
    |       |   |       |   |   |   |   |--EXPR -> EXPR [71:22]
    |       |   |       |   |   |   |   |   `--IDENT -> FRI [71:22]
    |       |   |       |   |   |   |   |--COMMA -> , [71:25]
    |       |   |       |   |   |   |   `--EXPR -> EXPR [71:27]
    |       |   |       |   |   |   |       `--IDENT -> SUN [71:27]
    |       |   |       |   |   |   |--LAMBDA -> -> [71:31]
    |       |   |       |   |   |   |--EXPR -> EXPR [71:34]
    |       |   |       |   |   |   |   `--NUM_INT -> 6 [71:34]
    |       |   |       |   |   |   `--SEMI -> ; [71:35]
    |       |   |       |   |   |--SWITCH_RULE -> SWITCH_RULE [72:12]
    |       |   |       |   |   |   |--LITERAL_CASE -> case [72:12]
    |       |   |       |   |   |   |   `--EXPR -> EXPR [72:17]
    |       |   |       |   |   |   |       `--IDENT -> TUE [72:17]
    |       |   |       |   |   |   |--LAMBDA -> -> [72:21]
    |       |   |       |   |   |   |--EXPR -> EXPR [72:24]
    |       |   |       |   |   |   |   `--NUM_INT -> 7 [72:24]
    |       |   |       |   |   |   `--SEMI -> ; [72:25]
    |       |   |       |   |   |--SWITCH_RULE -> SWITCH_RULE [73:12]
    |       |   |       |   |   |   |--LITERAL_CASE -> case [73:12]
    |       |   |       |   |   |   |   |--EXPR -> EXPR [73:17]
    |       |   |       |   |   |   |   |   `--IDENT -> THU [73:17]
    |       |   |       |   |   |   |   |--COMMA -> , [73:20]
    |       |   |       |   |   |   |   `--EXPR -> EXPR [73:22]
    |       |   |       |   |   |   |       `--IDENT -> SAT [73:22]
    |       |   |       |   |   |   |--LAMBDA -> -> [73:26]
    |       |   |       |   |   |   |--EXPR -> EXPR [73:29]
    |       |   |       |   |   |   |   `--NUM_INT -> 8 [73:29]
    |       |   |       |   |   |   `--SEMI -> ; [73:30]
    |       |   |       |   |   |--SWITCH_RULE -> SWITCH_RULE [74:12]
    |       |   |       |   |   |   |--LITERAL_CASE -> case [74:12]
    |       |   |       |   |   |   |   `--EXPR -> EXPR [74:17]
    |       |   |       |   |   |   |       `--IDENT -> WED [74:17]
    |       |   |       |   |   |   |--LAMBDA -> -> [74:21]
    |       |   |       |   |   |   |--EXPR -> EXPR [74:24]
    |       |   |       |   |   |   |   `--NUM_INT -> 9 [74:24]
    |       |   |       |   |   |   `--SEMI -> ; [74:25]
    |       |   |       |   |   `--RCURLY -> } [75:8]
    |       |   |       |   `--NUM_INT -> 7 [75:12]
    |       |   |       |--STRING_LITERAL -> "long" [75:16]
    |       |   |       |--COLON -> : [75:23]
    |       |   |       `--STRING_LITERAL -> "short" [75:25]
    |       |   `--SEMI -> ; [75:32]
    |       `--RCURLY -> } [76:4]
    |--METHOD_DEF -> METHOD_DEF [78:4]
    |   |--MODIFIERS -> MODIFIERS [78:4]
    |   |--TYPE -> TYPE [78:4]
    |   |   `--LITERAL_INT -> int [78:4]
    |   |--IDENT -> assignement [78:8]
    |   |--LPAREN -> ( [78:19]
    |   |--PARAMETERS -> PARAMETERS [78:20]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [78:20]
    |   |       |--MODIFIERS -> MODIFIERS [78:20]
    |   |       |--TYPE -> TYPE [78:20]
    |   |       |   `--IDENT -> Day [78:20]
    |   |       `--IDENT -> day [78:24]
    |   |--RPAREN -> ) [78:27]
    |   `--SLIST -> { [78:29]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [79:8]
    |       |   |--MODIFIERS -> MODIFIERS [79:8]
    |       |   |--TYPE -> TYPE [79:8]
    |       |   |   `--LITERAL_INT -> int [79:8]
    |       |   |--IDENT -> numLetters [79:12]
    |       |   `--ASSIGN -> = [79:23]
    |       |       `--EXPR -> EXPR [79:25]
    |       |           `--LITERAL_SWITCH -> switch [79:25]
    |       |               |--LPAREN -> ( [79:32]
    |       |               |--EXPR -> EXPR [79:33]
    |       |               |   `--IDENT -> day [79:33]
    |       |               |--RPAREN -> ) [79:36]
    |       |               |--LCURLY -> { [79:38]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [80:12]
    |       |               |   |--LITERAL_CASE -> case [80:12]
    |       |               |   |   |--EXPR -> EXPR [80:17]
    |       |               |   |   |   `--IDENT -> MON [80:17]
    |       |               |   |   |--COMMA -> , [80:20]
    |       |               |   |   |--EXPR -> EXPR [80:22]
    |       |               |   |   |   `--IDENT -> FRI [80:22]
    |       |               |   |   |--COMMA -> , [80:25]
    |       |               |   |   `--EXPR -> EXPR [80:27]
    |       |               |   |       `--IDENT -> SUN [80:27]
    |       |               |   |--LAMBDA -> -> [80:31]
    |       |               |   |--EXPR -> EXPR [80:34]
    |       |               |   |   `--NUM_INT -> 6 [80:34]
    |       |               |   `--SEMI -> ; [80:35]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [81:12]
    |       |               |   |--LITERAL_CASE -> case [81:12]
    |       |               |   |   `--EXPR -> EXPR [81:17]
    |       |               |   |       `--IDENT -> TUE [81:17]
    |       |               |   |--LAMBDA -> -> [81:21]
    |       |               |   |--EXPR -> EXPR [81:24]
    |       |               |   |   `--NUM_INT -> 7 [81:24]
    |       |               |   `--SEMI -> ; [81:25]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [82:12]
    |       |               |   |--LITERAL_CASE -> case [82:12]
    |       |               |   |   |--EXPR -> EXPR [82:17]
    |       |               |   |   |   `--IDENT -> THU [82:17]
    |       |               |   |   |--COMMA -> , [82:20]
    |       |               |   |   `--EXPR -> EXPR [82:22]
    |       |               |   |       `--IDENT -> SAT [82:22]
    |       |               |   |--LAMBDA -> -> [82:26]
    |       |               |   |--EXPR -> EXPR [82:29]
    |       |               |   |   `--NUM_INT -> 8 [82:29]
    |       |               |   `--SEMI -> ; [82:30]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [83:12]
    |       |               |   |--LITERAL_CASE -> case [83:12]
    |       |               |   |   `--EXPR -> EXPR [83:17]
    |       |               |   |       `--IDENT -> WED [83:17]
    |       |               |   |--LAMBDA -> -> [83:21]
    |       |               |   |--EXPR -> EXPR [83:24]
    |       |               |   |   `--NUM_INT -> 9 [83:24]
    |       |               |   `--SEMI -> ; [83:25]
    |       |               `--RCURLY -> } [84:8]
    |       |--SEMI -> ; [84:9]
    |       |--LITERAL_RETURN -> return [85:8]
    |       |   |--EXPR -> EXPR [85:15]
    |       |   |   `--IDENT -> numLetters [85:15]
    |       |   `--SEMI -> ; [85:25]
    |       `--RCURLY -> } [86:4]
    |--METHOD_DEF -> METHOD_DEF [88:4]
    |   |--MODIFIERS -> MODIFIERS [88:4]
    |   |   `--LITERAL_STATIC -> static [88:4]
    |   |--TYPE -> TYPE [88:11]
    |   |   `--LITERAL_VOID -> void [88:11]
    |   |--IDENT -> howMany [88:16]
    |   |--LPAREN -> ( [88:23]
    |   |--PARAMETERS -> PARAMETERS [88:24]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [88:24]
    |   |       |--MODIFIERS -> MODIFIERS [88:24]
    |   |       |--TYPE -> TYPE [88:24]
    |   |       |   `--LITERAL_INT -> int [88:24]
    |   |       `--IDENT -> k [88:28]
    |   |--RPAREN -> ) [88:29]
    |   `--SLIST -> { [88:31]
    |       |--LITERAL_SWITCH -> switch [89:8]
    |       |   |--LPAREN -> ( [89:15]
    |       |   |--EXPR -> EXPR [89:16]
    |       |   |   `--IDENT -> k [89:16]
    |       |   |--RPAREN -> ) [89:17]
    |       |   |--LCURLY -> { [89:19]
    |       |   |--SWITCH_RULE -> SWITCH_RULE [90:12]
    |       |   |   |--LITERAL_CASE -> case [90:12]
    |       |   |   |   `--EXPR -> EXPR [90:17]
    |       |   |   |       `--NUM_INT -> 1 [90:17]
    |       |   |   |--LAMBDA -> -> [90:19]
    |       |   |   |--EXPR -> EXPR [90:40]
    |       |   |   |   `--METHOD_CALL -> ( [90:40]
    |       |   |   |       |--DOT -> . [90:32]
    |       |   |   |       |   |--DOT -> . [90:28]
    |       |   |   |       |   |   |--IDENT -> System [90:22]
    |       |   |   |       |   |   `--IDENT -> out [90:29]
    |       |   |   |       |   `--IDENT -> println [90:33]
    |       |   |   |       |--ELIST -> ELIST [90:41]
    |       |   |   |       |   `--EXPR -> EXPR [90:41]
    |       |   |   |       |       `--STRING_LITERAL -> "one" [90:41]
    |       |   |   |       `--RPAREN -> ) [90:46]
    |       |   |   `--SEMI -> ; [90:47]
    |       |   |--SWITCH_RULE -> SWITCH_RULE [91:12]
    |       |   |   |--LITERAL_CASE -> case [91:12]
    |       |   |   |   `--EXPR -> EXPR [91:17]
    |       |   |   |       `--NUM_INT -> 2 [91:17]
    |       |   |   |--LAMBDA -> -> [91:19]
    |       |   |   |--EXPR -> EXPR [91:40]
    |       |   |   |   `--METHOD_CALL -> ( [91:40]
    |       |   |   |       |--DOT -> . [91:32]
    |       |   |   |       |   |--DOT -> . [91:28]
    |       |   |   |       |   |   |--IDENT -> System [91:22]
    |       |   |   |       |   |   `--IDENT -> out [91:29]
    |       |   |   |       |   `--IDENT -> println [91:33]
    |       |   |   |       |--ELIST -> ELIST [91:41]
    |       |   |   |       |   `--EXPR -> EXPR [91:41]
    |       |   |   |       |       `--STRING_LITERAL -> "two" [91:41]
    |       |   |   |       `--RPAREN -> ) [91:46]
    |       |   |   `--SEMI -> ; [91:47]
    |       |   |--SWITCH_RULE -> SWITCH_RULE [92:12]
    |       |   |   |--LITERAL_CASE -> case [92:12]
    |       |   |   |   `--EXPR -> EXPR [92:17]
    |       |   |   |       `--NUM_INT -> 3 [92:17]
    |       |   |   |--LAMBDA -> -> [92:19]
    |       |   |   |--EXPR -> EXPR [92:40]
    |       |   |   |   `--METHOD_CALL -> ( [92:40]
    |       |   |   |       |--DOT -> . [92:32]
    |       |   |   |       |   |--DOT -> . [92:28]
    |       |   |   |       |   |   |--IDENT -> System [92:22]
    |       |   |   |       |   |   `--IDENT -> out [92:29]
    |       |   |   |       |   `--IDENT -> println [92:33]
    |       |   |   |       |--ELIST -> ELIST [92:41]
    |       |   |   |       |   `--EXPR -> EXPR [92:41]
    |       |   |   |       |       `--STRING_LITERAL -> "many" [92:41]
    |       |   |   |       `--RPAREN -> ) [92:47]
    |       |   |   `--SEMI -> ; [92:48]
    |       |   |--SWITCH_RULE -> SWITCH_RULE [93:12]
    |       |   |   |--LITERAL_DEFAULT -> default [93:12]
    |       |   |   |--LAMBDA -> -> [93:20]
    |       |   |   `--LITERAL_THROW -> throw [93:23]
    |       |   |       |--EXPR -> EXPR [93:29]
    |       |   |       |   `--LITERAL_NEW -> new [93:29]
    |       |   |       |       |--IDENT -> IllegalArgumentException [93:33]
    |       |   |       |       |--LPAREN -> ( [93:57]
    |       |   |       |       |--ELIST -> ELIST [93:58]
    |       |   |       |       |   `--EXPR -> EXPR [93:58]
    |       |   |       |       |       `--STRING_LITERAL -> "Unknown" [93:58]
    |       |   |       |       `--RPAREN -> ) [93:67]
    |       |   |       `--SEMI -> ; [93:68]
    |       |   `--RCURLY -> } [94:8]
    |       `--RCURLY -> } [95:4]
    |--METHOD_DEF -> METHOD_DEF [97:4]
    |   |--MODIFIERS -> MODIFIERS [97:4]
    |   |--TYPE -> TYPE [97:4]
    |   |   `--LITERAL_INT -> int [97:4]
    |   |--IDENT -> methodCalls [97:8]
    |   |--LPAREN -> ( [97:19]
    |   |--PARAMETERS -> PARAMETERS [97:20]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [97:20]
    |   |       |--MODIFIERS -> MODIFIERS [97:20]
    |   |       |--TYPE -> TYPE [97:20]
    |   |       |   `--IDENT -> Day [97:20]
    |   |       `--IDENT -> day [97:24]
    |   |--RPAREN -> ) [97:27]
    |   `--SLIST -> { [97:29]
    |       |--LITERAL_RETURN -> return [98:8]
    |       |   |--EXPR -> EXPR [98:15]
    |       |   |   `--LITERAL_SWITCH -> switch [98:15]
    |       |   |       |--LPAREN -> ( [98:22]
    |       |   |       |--EXPR -> EXPR [98:23]
    |       |   |       |   `--IDENT -> day [98:23]
    |       |   |       |--RPAREN -> ) [98:26]
    |       |   |       |--LCURLY -> { [98:28]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [99:12]
    |       |   |       |   |--LITERAL_CASE -> case [99:12]
    |       |   |       |   |   |--EXPR -> EXPR [99:17]
    |       |   |       |   |   |   `--IDENT -> MON [99:17]
    |       |   |       |   |   |--COMMA -> , [99:20]
    |       |   |       |   |   `--EXPR -> EXPR [99:22]
    |       |   |       |   |       `--IDENT -> TUE [99:22]
    |       |   |       |   |--LAMBDA -> -> [99:26]
    |       |   |       |   |--EXPR -> EXPR [99:42]
    |       |   |       |   |   `--METHOD_CALL -> ( [99:42]
    |       |   |       |   |       |--DOT -> . [99:33]
    |       |   |       |   |       |   |--IDENT -> Math [99:29]
    |       |   |       |   |       |   `--IDENT -> addExact [99:34]
    |       |   |       |   |       |--ELIST -> ELIST [99:43]
    |       |   |       |   |       |   |--EXPR -> EXPR [99:43]
    |       |   |       |   |       |   |   `--NUM_INT -> 0 [99:43]
    |       |   |       |   |       |   |--COMMA -> , [99:44]
    |       |   |       |   |       |   `--EXPR -> EXPR [99:46]
    |       |   |       |   |       |       `--NUM_INT -> 1 [99:46]
    |       |   |       |   |       `--RPAREN -> ) [99:47]
    |       |   |       |   `--SEMI -> ; [99:48]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [100:12]
    |       |   |       |   |--LITERAL_CASE -> case [100:12]
    |       |   |       |   |   `--EXPR -> EXPR [100:17]
    |       |   |       |   |       `--IDENT -> WED [100:17]
    |       |   |       |   |--LAMBDA -> -> [100:21]
    |       |   |       |   |--EXPR -> EXPR [100:37]
    |       |   |       |   |   `--METHOD_CALL -> ( [100:37]
    |       |   |       |   |       |--DOT -> . [100:28]
    |       |   |       |   |       |   |--IDENT -> Math [100:24]
    |       |   |       |   |       |   `--IDENT -> addExact [100:29]
    |       |   |       |   |       |--ELIST -> ELIST [100:38]
    |       |   |       |   |       |   |--EXPR -> EXPR [100:38]
    |       |   |       |   |       |   |   `--NUM_INT -> 1 [100:38]
    |       |   |       |   |       |   |--COMMA -> , [100:39]
    |       |   |       |   |       |   `--EXPR -> EXPR [100:41]
    |       |   |       |   |       |       `--NUM_INT -> 1 [100:41]
    |       |   |       |   |       `--RPAREN -> ) [100:42]
    |       |   |       |   `--SEMI -> ; [100:43]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [101:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [101:12]
    |       |   |       |   |--LAMBDA -> -> [101:20]
    |       |   |       |   `--SLIST -> { [101:23]
    |       |   |       |       |--LITERAL_YIELD -> yield [102:16]
    |       |   |       |       |   |--EXPR -> EXPR [102:35]
    |       |   |       |       |   |   `--METHOD_CALL -> ( [102:35]
    |       |   |       |       |   |       |--DOT -> . [102:26]
    |       |   |       |       |   |       |   |--IDENT -> Math [102:22]
    |       |   |       |       |   |       |   `--IDENT -> addExact [102:27]
    |       |   |       |       |   |       |--ELIST -> ELIST [102:36]
    |       |   |       |       |   |       |   |--EXPR -> EXPR [102:36]
    |       |   |       |       |   |       |   |   `--NUM_INT -> 2 [102:36]
    |       |   |       |       |   |       |   |--COMMA -> , [102:37]
    |       |   |       |       |   |       |   `--EXPR -> EXPR [102:39]
    |       |   |       |       |   |       |       `--NUM_INT -> 1 [102:39]
    |       |   |       |       |   |       `--RPAREN -> ) [102:40]
    |       |   |       |       |   `--SEMI -> ; [102:41]
    |       |   |       |       `--RCURLY -> } [103:12]
    |       |   |       `--RCURLY -> } [104:8]
    |       |   `--SEMI -> ; [104:9]
    |       `--RCURLY -> } [105:4]
    |--METHOD_DEF -> METHOD_DEF [107:4]
    |   |--MODIFIERS -> MODIFIERS [107:4]
    |   |--TYPE -> TYPE [107:4]
    |   |   `--LITERAL_INT -> int [107:4]
    |   |--IDENT -> yieldAcceptsExpressions [107:8]
    |   |--LPAREN -> ( [107:31]
    |   |--PARAMETERS -> PARAMETERS [107:32]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [107:32]
    |   |       |--MODIFIERS -> MODIFIERS [107:32]
    |   |       |--TYPE -> TYPE [107:32]
    |   |       |   `--IDENT -> Day [107:32]
    |   |       `--IDENT -> day [107:36]
    |   |--RPAREN -> ) [107:39]
    |   `--SLIST -> { [107:41]
    |       |--LITERAL_RETURN -> return [108:8]
    |       |   |--EXPR -> EXPR [108:15]
    |       |   |   `--LITERAL_SWITCH -> switch [108:15]
    |       |   |       |--LPAREN -> ( [108:22]
    |       |   |       |--EXPR -> EXPR [108:23]
    |       |   |       |   `--IDENT -> day [108:23]
    |       |   |       |--RPAREN -> ) [108:26]
    |       |   |       |--LCURLY -> { [108:28]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [109:12]
    |       |   |       |   |--LITERAL_CASE -> case [109:12]
    |       |   |       |   |   |--EXPR -> EXPR [109:17]
    |       |   |       |   |   |   `--IDENT -> MON [109:17]
    |       |   |       |   |   |--COMMA -> , [109:20]
    |       |   |       |   |   `--EXPR -> EXPR [109:22]
    |       |   |       |   |       `--IDENT -> TUE [109:22]
    |       |   |       |   |--LAMBDA -> -> [109:26]
    |       |   |       |   |--EXPR -> EXPR [109:29]
    |       |   |       |   |   `--NUM_INT -> 0 [109:29]
    |       |   |       |   `--SEMI -> ; [109:30]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [110:12]
    |       |   |       |   |--LITERAL_CASE -> case [110:12]
    |       |   |       |   |   `--EXPR -> EXPR [110:17]
    |       |   |       |   |       `--IDENT -> WED [110:17]
    |       |   |       |   |--LAMBDA -> -> [110:21]
    |       |   |       |   |--EXPR -> EXPR [110:24]
    |       |   |       |   |   `--NUM_INT -> 1 [110:24]
    |       |   |       |   `--SEMI -> ; [110:25]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [111:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [111:12]
    |       |   |       |   |--LAMBDA -> -> [111:20]
    |       |   |       |   |--EXPR -> EXPR [111:51]
    |       |   |       |   |   `--QUESTION -> ? [111:51]
    |       |   |       |   |       |--GT -> > [111:47]
    |       |   |       |   |       |   |--METHOD_CALL -> ( [111:44]
    |       |   |       |   |       |   |   |--DOT -> . [111:37]
    |       |   |       |   |       |   |   |   |--METHOD_CALL -> ( [111:35]
    |       |   |       |   |       |   |   |   |   |--DOT -> . [111:26]
    |       |   |       |   |       |   |   |   |   |   |--IDENT -> day [111:23]
    |       |   |       |   |       |   |   |   |   |   `--IDENT -> toString [111:27]
    |       |   |       |   |       |   |   |   |   |--ELIST -> ELIST [111:36]
    |       |   |       |   |       |   |   |   |   `--RPAREN -> ) [111:36]
    |       |   |       |   |       |   |   |   `--IDENT -> length [111:38]
    |       |   |       |   |       |   |   |--ELIST -> ELIST [111:45]
    |       |   |       |   |       |   |   `--RPAREN -> ) [111:45]
    |       |   |       |   |       |   `--NUM_INT -> 5 [111:49]
    |       |   |       |   |       |--NUM_INT -> 1 [111:53]
    |       |   |       |   |       |--COLON -> : [111:55]
    |       |   |       |   |       `--NUM_INT -> 0 [111:57]
    |       |   |       |   `--SEMI -> ; [111:58]
    |       |   |       `--RCURLY -> } [112:8]
    |       |   `--SEMI -> ; [112:9]
    |       `--RCURLY -> } [113:4]
    |--METHOD_DEF -> METHOD_DEF [115:4]
    |   |--MODIFIERS -> MODIFIERS [115:4]
    |   |--TYPE -> TYPE [115:4]
    |   |   `--LITERAL_INT -> int [115:4]
    |   |--IDENT -> complexCase [115:8]
    |   |--LPAREN -> ( [115:19]
    |   |--PARAMETERS -> PARAMETERS [115:20]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [115:20]
    |   |       |--MODIFIERS -> MODIFIERS [115:20]
    |   |       |--TYPE -> TYPE [115:20]
    |   |       |   `--IDENT -> Day [115:20]
    |   |       `--IDENT -> day [115:24]
    |   |--RPAREN -> ) [115:27]
    |   `--SLIST -> { [115:29]
    |       |--LITERAL_RETURN -> return [116:8]
    |       |   |--EXPR -> EXPR [116:15]
    |       |   |   `--LITERAL_SWITCH -> switch [116:15]
    |       |   |       |--LPAREN -> ( [116:22]
    |       |   |       |--EXPR -> EXPR [116:23]
    |       |   |       |   `--IDENT -> day [116:23]
    |       |   |       |--RPAREN -> ) [116:26]
    |       |   |       |--LCURLY -> { [116:28]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [117:12]
    |       |   |       |   |--LITERAL_CASE -> case [117:12]
    |       |   |       |   |   |--EXPR -> EXPR [117:17]
    |       |   |       |   |   |   `--IDENT -> MON [117:17]
    |       |   |       |   |   |--COMMA -> , [117:20]
    |       |   |       |   |   `--EXPR -> EXPR [117:22]
    |       |   |       |   |       `--IDENT -> TUE [117:22]
    |       |   |       |   |--LAMBDA -> -> [117:26]
    |       |   |       |   `--SLIST -> { [117:29]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [118:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [118:16]
    |       |   |       |       |   |--TYPE -> TYPE [118:16]
    |       |   |       |       |   |   `--LITERAL_INT -> int [118:16]
    |       |   |       |       |   |--IDENT -> l [118:20]
    |       |   |       |       |   `--ASSIGN -> = [118:22]
    |       |   |       |       |       `--EXPR -> EXPR [118:45]
    |       |   |       |       |           `--METHOD_CALL -> ( [118:45]
    |       |   |       |       |               |--DOT -> . [118:38]
    |       |   |       |       |               |   |--METHOD_CALL -> ( [118:36]
    |       |   |       |       |               |   |   |--DOT -> . [118:27]
    |       |   |       |       |               |   |   |   |--IDENT -> day [118:24]
    |       |   |       |       |               |   |   |   `--IDENT -> toString [118:28]
    |       |   |       |       |               |   |   |--ELIST -> ELIST [118:37]
    |       |   |       |       |               |   |   `--RPAREN -> ) [118:37]
    |       |   |       |       |               |   `--IDENT -> length [118:39]
    |       |   |       |       |               |--ELIST -> ELIST [118:46]
    |       |   |       |       |               `--RPAREN -> ) [118:46]
    |       |   |       |       |--SEMI -> ; [118:47]
    |       |   |       |       |--LITERAL_YIELD -> yield [119:16]
    |       |   |       |       |   |--EXPR -> EXPR [119:35]
    |       |   |       |       |   |   `--METHOD_CALL -> ( [119:35]
    |       |   |       |       |   |       |--DOT -> . [119:26]
    |       |   |       |       |   |       |   |--IDENT -> Math [119:22]
    |       |   |       |       |   |       |   `--IDENT -> addExact [119:27]
    |       |   |       |       |   |       |--ELIST -> ELIST [119:36]
    |       |   |       |       |   |       |   |--EXPR -> EXPR [119:36]
    |       |   |       |       |   |       |   |   `--IDENT -> l [119:36]
    |       |   |       |       |   |       |   |--COMMA -> , [119:37]
    |       |   |       |       |   |       |   `--EXPR -> EXPR [119:39]
    |       |   |       |       |   |       |       `--NUM_INT -> 0 [119:39]
    |       |   |       |       |   |       `--RPAREN -> ) [119:40]
    |       |   |       |       |   `--SEMI -> ; [119:41]
    |       |   |       |       `--RCURLY -> } [120:12]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [121:12]
    |       |   |       |   |--LITERAL_CASE -> case [121:12]
    |       |   |       |   |   `--EXPR -> EXPR [121:17]
    |       |   |       |   |       `--IDENT -> WED [121:17]
    |       |   |       |   |--LAMBDA -> -> [121:21]
    |       |   |       |   `--SLIST -> { [121:24]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [122:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [122:16]
    |       |   |       |       |   |--TYPE -> TYPE [122:16]
    |       |   |       |       |   |   `--LITERAL_INT -> int [122:16]
    |       |   |       |       |   |--IDENT -> l [122:20]
    |       |   |       |       |   `--ASSIGN -> = [122:22]
    |       |   |       |       |       `--EXPR -> EXPR [122:45]
    |       |   |       |       |           `--METHOD_CALL -> ( [122:45]
    |       |   |       |       |               |--DOT -> . [122:38]
    |       |   |       |       |               |   |--METHOD_CALL -> ( [122:36]
    |       |   |       |       |               |   |   |--DOT -> . [122:27]
    |       |   |       |       |               |   |   |   |--IDENT -> day [122:24]
    |       |   |       |       |               |   |   |   `--IDENT -> toString [122:28]
    |       |   |       |       |               |   |   |--ELIST -> ELIST [122:37]
    |       |   |       |       |               |   |   `--RPAREN -> ) [122:37]
    |       |   |       |       |               |   `--IDENT -> length [122:39]
    |       |   |       |       |               |--ELIST -> ELIST [122:46]
    |       |   |       |       |               `--RPAREN -> ) [122:46]
    |       |   |       |       |--SEMI -> ; [122:47]
    |       |   |       |       |--LITERAL_YIELD -> yield [123:16]
    |       |   |       |       |   |--EXPR -> EXPR [123:35]
    |       |   |       |       |   |   `--METHOD_CALL -> ( [123:35]
    |       |   |       |       |   |       |--DOT -> . [123:26]
    |       |   |       |       |   |       |   |--IDENT -> Math [123:22]
    |       |   |       |       |   |       |   `--IDENT -> addExact [123:27]
    |       |   |       |       |   |       |--ELIST -> ELIST [123:36]
    |       |   |       |       |   |       |   |--EXPR -> EXPR [123:36]
    |       |   |       |       |   |       |   |   `--IDENT -> l [123:36]
    |       |   |       |       |   |       |   |--COMMA -> , [123:37]
    |       |   |       |       |   |       |   `--EXPR -> EXPR [123:39]
    |       |   |       |       |   |       |       `--NUM_INT -> 1 [123:39]
    |       |   |       |       |   |       `--RPAREN -> ) [123:40]
    |       |   |       |       |   `--SEMI -> ; [123:41]
    |       |   |       |       `--RCURLY -> } [124:12]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [125:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [125:12]
    |       |   |       |   |--LAMBDA -> -> [125:20]
    |       |   |       |   `--SLIST -> { [125:23]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [126:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [126:16]
    |       |   |       |       |   |--TYPE -> TYPE [126:16]
    |       |   |       |       |   |   `--LITERAL_INT -> int [126:16]
    |       |   |       |       |   |--IDENT -> l [126:20]
    |       |   |       |       |   `--ASSIGN -> = [126:22]
    |       |   |       |       |       `--EXPR -> EXPR [126:45]
    |       |   |       |       |           `--METHOD_CALL -> ( [126:45]
    |       |   |       |       |               |--DOT -> . [126:38]
    |       |   |       |       |               |   |--METHOD_CALL -> ( [126:36]
    |       |   |       |       |               |   |   |--DOT -> . [126:27]
    |       |   |       |       |               |   |   |   |--IDENT -> day [126:24]
    |       |   |       |       |               |   |   |   `--IDENT -> toString [126:28]
    |       |   |       |       |               |   |   |--ELIST -> ELIST [126:37]
    |       |   |       |       |               |   |   `--RPAREN -> ) [126:37]
    |       |   |       |       |               |   `--IDENT -> length [126:39]
    |       |   |       |       |               |--ELIST -> ELIST [126:46]
    |       |   |       |       |               `--RPAREN -> ) [126:46]
    |       |   |       |       |--SEMI -> ; [126:47]
    |       |   |       |       |--LITERAL_YIELD -> yield [127:16]
    |       |   |       |       |   |--EXPR -> EXPR [127:35]
    |       |   |       |       |   |   `--METHOD_CALL -> ( [127:35]
    |       |   |       |       |   |       |--DOT -> . [127:26]
    |       |   |       |       |   |       |   |--IDENT -> Math [127:22]
    |       |   |       |       |   |       |   `--IDENT -> addExact [127:27]
    |       |   |       |       |   |       |--ELIST -> ELIST [127:36]
    |       |   |       |       |   |       |   |--EXPR -> EXPR [127:36]
    |       |   |       |       |   |       |   |   `--IDENT -> l [127:36]
    |       |   |       |       |   |       |   |--COMMA -> , [127:37]
    |       |   |       |       |   |       |   `--EXPR -> EXPR [127:39]
    |       |   |       |       |   |       |       `--NUM_INT -> 2 [127:39]
    |       |   |       |       |   |       `--RPAREN -> ) [127:40]
    |       |   |       |       |   `--SEMI -> ; [127:41]
    |       |   |       |       `--RCURLY -> } [128:12]
    |       |   |       `--RCURLY -> } [129:8]
    |       |   `--SEMI -> ; [129:9]
    |       `--RCURLY -> } [130:4]
    |--METHOD_DEF -> METHOD_DEF [132:4]
    |   |--MODIFIERS -> MODIFIERS [132:4]
    |   |--TYPE -> TYPE [132:4]
    |   |   `--LITERAL_INT -> int [132:4]
    |   |--IDENT -> arithmetic [132:8]
    |   |--LPAREN -> ( [132:18]
    |   |--PARAMETERS -> PARAMETERS [132:19]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [132:19]
    |   |       |--MODIFIERS -> MODIFIERS [132:19]
    |   |       |--TYPE -> TYPE [132:19]
    |   |       |   `--IDENT -> Day [132:19]
    |   |       `--IDENT -> day [132:23]
    |   |--RPAREN -> ) [132:26]
    |   `--SLIST -> { [132:28]
    |       |--LITERAL_RETURN -> return [133:8]
    |       |   |--EXPR -> EXPR [138:10]
    |       |   |   `--MOD -> % [138:10]
    |       |   |       |--LITERAL_SWITCH -> switch [133:15]
    |       |   |       |   |--LPAREN -> ( [133:22]
    |       |   |       |   |--EXPR -> EXPR [133:23]
    |       |   |       |   |   `--IDENT -> day [133:23]
    |       |   |       |   |--RPAREN -> ) [133:26]
    |       |   |       |   |--LCURLY -> { [133:28]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [134:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [134:12]
    |       |   |       |   |   |   |--EXPR -> EXPR [134:17]
    |       |   |       |   |   |   |   `--IDENT -> MON [134:17]
    |       |   |       |   |   |   |--COMMA -> , [134:20]
    |       |   |       |   |   |   |--EXPR -> EXPR [134:22]
    |       |   |       |   |   |   |   `--IDENT -> FRI [134:22]
    |       |   |       |   |   |   |--COMMA -> , [134:25]
    |       |   |       |   |   |   `--EXPR -> EXPR [134:27]
    |       |   |       |   |   |       `--IDENT -> SUN [134:27]
    |       |   |       |   |   |--LAMBDA -> -> [134:31]
    |       |   |       |   |   |--EXPR -> EXPR [134:34]
    |       |   |       |   |   |   `--NUM_INT -> 6 [134:34]
    |       |   |       |   |   `--SEMI -> ; [134:35]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [135:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [135:12]
    |       |   |       |   |   |   `--EXPR -> EXPR [135:17]
    |       |   |       |   |   |       `--IDENT -> TUE [135:17]
    |       |   |       |   |   |--LAMBDA -> -> [135:21]
    |       |   |       |   |   |--EXPR -> EXPR [135:24]
    |       |   |       |   |   |   `--NUM_INT -> 7 [135:24]
    |       |   |       |   |   `--SEMI -> ; [135:25]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [136:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [136:12]
    |       |   |       |   |   |   |--EXPR -> EXPR [136:17]
    |       |   |       |   |   |   |   `--IDENT -> THU [136:17]
    |       |   |       |   |   |   |--COMMA -> , [136:20]
    |       |   |       |   |   |   `--EXPR -> EXPR [136:22]
    |       |   |       |   |   |       `--IDENT -> SAT [136:22]
    |       |   |       |   |   |--LAMBDA -> -> [136:26]
    |       |   |       |   |   |--EXPR -> EXPR [136:29]
    |       |   |       |   |   |   `--NUM_INT -> 8 [136:29]
    |       |   |       |   |   `--SEMI -> ; [136:30]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [137:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [137:12]
    |       |   |       |   |   |   `--EXPR -> EXPR [137:17]
    |       |   |       |   |   |       `--IDENT -> WED [137:17]
    |       |   |       |   |   |--LAMBDA -> -> [137:21]
    |       |   |       |   |   |--EXPR -> EXPR [137:24]
    |       |   |       |   |   |   `--NUM_INT -> 9 [137:24]
    |       |   |       |   |   `--SEMI -> ; [137:25]
    |       |   |       |   `--RCURLY -> } [138:8]
    |       |   |       `--NUM_INT -> 2 [138:12]
    |       |   `--SEMI -> ; [138:13]
    |       `--RCURLY -> } [139:4]
    |--METHOD_DEF -> METHOD_DEF [141:4]
    |   |--MODIFIERS -> MODIFIERS [141:4]
    |   |--TYPE -> TYPE [141:4]
    |   |   `--LITERAL_INT -> int [141:4]
    |   |--IDENT -> signArithmetic [141:8]
    |   |--LPAREN -> ( [141:22]
    |   |--PARAMETERS -> PARAMETERS [141:23]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [141:23]
    |   |       |--MODIFIERS -> MODIFIERS [141:23]
    |   |       |--TYPE -> TYPE [141:23]
    |   |       |   `--IDENT -> Day [141:23]
    |   |       `--IDENT -> day [141:27]
    |   |--RPAREN -> ) [141:30]
    |   `--SLIST -> { [141:32]
    |       |--LITERAL_RETURN -> return [142:8]
    |       |   |--EXPR -> EXPR [142:15]
    |       |   |   `--UNARY_MINUS -> - [142:15]
    |       |   |       `--LITERAL_SWITCH -> switch [142:16]
    |       |   |           |--LPAREN -> ( [142:23]
    |       |   |           |--EXPR -> EXPR [142:24]
    |       |   |           |   `--IDENT -> day [142:24]
    |       |   |           |--RPAREN -> ) [142:27]
    |       |   |           |--LCURLY -> { [142:29]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [143:12]
    |       |   |           |   |--LITERAL_CASE -> case [143:12]
    |       |   |           |   |   |--EXPR -> EXPR [143:17]
    |       |   |           |   |   |   `--IDENT -> MON [143:17]
    |       |   |           |   |   |--COMMA -> , [143:20]
    |       |   |           |   |   |--EXPR -> EXPR [143:22]
    |       |   |           |   |   |   `--IDENT -> FRI [143:22]
    |       |   |           |   |   |--COMMA -> , [143:25]
    |       |   |           |   |   `--EXPR -> EXPR [143:27]
    |       |   |           |   |       `--IDENT -> SUN [143:27]
    |       |   |           |   |--LAMBDA -> -> [143:31]
    |       |   |           |   |--EXPR -> EXPR [143:34]
    |       |   |           |   |   `--NUM_INT -> 6 [143:34]
    |       |   |           |   `--SEMI -> ; [143:35]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [144:12]
    |       |   |           |   |--LITERAL_CASE -> case [144:12]
    |       |   |           |   |   `--EXPR -> EXPR [144:17]
    |       |   |           |   |       `--IDENT -> TUE [144:17]
    |       |   |           |   |--LAMBDA -> -> [144:21]
    |       |   |           |   |--EXPR -> EXPR [144:24]
    |       |   |           |   |   `--NUM_INT -> 7 [144:24]
    |       |   |           |   `--SEMI -> ; [144:25]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [145:12]
    |       |   |           |   |--LITERAL_CASE -> case [145:12]
    |       |   |           |   |   |--EXPR -> EXPR [145:17]
    |       |   |           |   |   |   `--IDENT -> THU [145:17]
    |       |   |           |   |   |--COMMA -> , [145:20]
    |       |   |           |   |   `--EXPR -> EXPR [145:22]
    |       |   |           |   |       `--IDENT -> SAT [145:22]
    |       |   |           |   |--LAMBDA -> -> [145:26]
    |       |   |           |   |--EXPR -> EXPR [145:29]
    |       |   |           |   |   `--NUM_INT -> 8 [145:29]
    |       |   |           |   `--SEMI -> ; [145:30]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [146:12]
    |       |   |           |   |--LITERAL_CASE -> case [146:12]
    |       |   |           |   |   `--EXPR -> EXPR [146:17]
    |       |   |           |   |       `--IDENT -> WED [146:17]
    |       |   |           |   |--LAMBDA -> -> [146:21]
    |       |   |           |   |--EXPR -> EXPR [146:24]
    |       |   |           |   |   `--NUM_INT -> 9 [146:24]
    |       |   |           |   `--SEMI -> ; [146:25]
    |       |   |           `--RCURLY -> } [147:8]
    |       |   `--SEMI -> ; [147:9]
    |       `--RCURLY -> } [148:4]
    |--METHOD_DEF -> METHOD_DEF [150:4]
    |   |--MODIFIERS -> MODIFIERS [150:4]
    |   |--TYPE -> TYPE [150:4]
    |   |   `--LITERAL_INT -> int [150:4]
    |   |--IDENT -> usedOnBothSidesOfArithmeticExpression [150:8]
    |   |--LPAREN -> ( [150:45]
    |   |--PARAMETERS -> PARAMETERS [150:46]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [150:46]
    |   |       |--MODIFIERS -> MODIFIERS [150:46]
    |   |       |--TYPE -> TYPE [150:46]
    |   |       |   `--IDENT -> Day [150:46]
    |   |       `--IDENT -> day [150:50]
    |   |--RPAREN -> ) [150:53]
    |   `--SLIST -> { [150:55]
    |       |--LITERAL_RETURN -> return [151:8]
    |       |   |--EXPR -> EXPR [155:10]
    |       |   |   `--STAR -> * [155:10]
    |       |   |       |--LITERAL_SWITCH -> switch [151:15]
    |       |   |       |   |--LPAREN -> ( [151:22]
    |       |   |       |   |--EXPR -> EXPR [151:23]
    |       |   |       |   |   `--IDENT -> day [151:23]
    |       |   |       |   |--RPAREN -> ) [151:26]
    |       |   |       |   |--LCURLY -> { [151:28]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [152:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [152:12]
    |       |   |       |   |   |   |--EXPR -> EXPR [152:17]
    |       |   |       |   |   |   |   `--IDENT -> MON [152:17]
    |       |   |       |   |   |   |--COMMA -> , [152:20]
    |       |   |       |   |   |   `--EXPR -> EXPR [152:22]
    |       |   |       |   |   |       `--IDENT -> TUE [152:22]
    |       |   |       |   |   |--LAMBDA -> -> [152:26]
    |       |   |       |   |   |--EXPR -> EXPR [152:29]
    |       |   |       |   |   |   `--NUM_INT -> 0 [152:29]
    |       |   |       |   |   `--SEMI -> ; [152:30]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [153:12]
    |       |   |       |   |   |--LITERAL_CASE -> case [153:12]
    |       |   |       |   |   |   `--EXPR -> EXPR [153:17]
    |       |   |       |   |   |       `--IDENT -> WED [153:17]
    |       |   |       |   |   |--LAMBDA -> -> [153:21]
    |       |   |       |   |   |--EXPR -> EXPR [153:24]
    |       |   |       |   |   |   `--NUM_INT -> 1 [153:24]
    |       |   |       |   |   `--SEMI -> ; [153:25]
    |       |   |       |   |--SWITCH_RULE -> SWITCH_RULE [154:12]
    |       |   |       |   |   |--LITERAL_DEFAULT -> default [154:12]
    |       |   |       |   |   |--LAMBDA -> -> [154:20]
    |       |   |       |   |   |--EXPR -> EXPR [154:23]
    |       |   |       |   |   |   `--NUM_INT -> 2 [154:23]
    |       |   |       |   |   `--SEMI -> ; [154:24]
    |       |   |       |   `--RCURLY -> } [155:8]
    |       |   |       `--LITERAL_SWITCH -> switch [155:12]
    |       |   |           |--LPAREN -> ( [155:19]
    |       |   |           |--EXPR -> EXPR [155:20]
    |       |   |           |   `--IDENT -> day [155:20]
    |       |   |           |--RPAREN -> ) [155:23]
    |       |   |           |--LCURLY -> { [155:25]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [156:12]
    |       |   |           |   |--LITERAL_CASE -> case [156:12]
    |       |   |           |   |   |--EXPR -> EXPR [156:17]
    |       |   |           |   |   |   `--IDENT -> WED [156:17]
    |       |   |           |   |   |--COMMA -> , [156:20]
    |       |   |           |   |   `--EXPR -> EXPR [156:22]
    |       |   |           |   |       `--IDENT -> THU [156:22]
    |       |   |           |   |--LAMBDA -> -> [156:26]
    |       |   |           |   |--EXPR -> EXPR [156:29]
    |       |   |           |   |   `--NUM_INT -> 3 [156:29]
    |       |   |           |   `--SEMI -> ; [156:30]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [157:12]
    |       |   |           |   |--LITERAL_CASE -> case [157:12]
    |       |   |           |   |   `--EXPR -> EXPR [157:17]
    |       |   |           |   |       `--IDENT -> FRI [157:17]
    |       |   |           |   |--LAMBDA -> -> [157:21]
    |       |   |           |   |--EXPR -> EXPR [157:24]
    |       |   |           |   |   `--NUM_INT -> 4 [157:24]
    |       |   |           |   `--SEMI -> ; [157:25]
    |       |   |           |--SWITCH_RULE -> SWITCH_RULE [158:12]
    |       |   |           |   |--LITERAL_DEFAULT -> default [158:12]
    |       |   |           |   |--LAMBDA -> -> [158:20]
    |       |   |           |   |--EXPR -> EXPR [158:23]
    |       |   |           |   |   `--NUM_INT -> 5 [158:23]
    |       |   |           |   `--SEMI -> ; [158:24]
    |       |   |           `--RCURLY -> } [159:8]
    |       |   `--SEMI -> ; [159:9]
    |       `--RCURLY -> } [160:4]
    |--INSTANCE_INIT -> INSTANCE_INIT [162:4]
    |   `--SLIST -> { [162:4]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [163:8]
    |       |   |--MODIFIERS -> MODIFIERS [163:8]
    |       |   |--TYPE -> TYPE [163:8]
    |       |   |   `--IDENT -> Integer [163:8]
    |       |   |--IDENT -> i [163:16]
    |       |   `--ASSIGN -> = [163:18]
    |       |       `--EXPR -> EXPR [163:20]
    |       |           `--NUM_INT -> 0 [163:20]
    |       |--SEMI -> ; [163:21]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [164:8]
    |       |   |--MODIFIERS -> MODIFIERS [164:8]
    |       |   |--TYPE -> TYPE [164:8]
    |       |   |   `--IDENT -> Object [164:8]
    |       |   |--IDENT -> o1 [164:15]
    |       |   `--ASSIGN -> = [164:18]
    |       |       `--EXPR -> EXPR [164:20]
    |       |           `--STRING_LITERAL -> "o1" [164:20]
    |       |--SEMI -> ; [164:24]
    |       |--LITERAL_IF -> if [166:8]
    |       |   |--LPAREN -> ( [166:11]
    |       |   |--EXPR -> EXPR [166:12]
    |       |   |   `--LNOT -> ! [166:12]
    |       |   |       `--LITERAL_SWITCH -> switch [166:13]
    |       |   |           |--LPAREN -> ( [166:20]
    |       |   |           |--EXPR -> EXPR [166:21]
    |       |   |           |   `--IDENT -> i [166:21]
    |       |   |           |--RPAREN -> ) [166:22]
    |       |   |           |--LCURLY -> { [166:24]
    |       |   |           |--CASE_GROUP -> CASE_GROUP [167:12]
    |       |   |           |   |--LITERAL_DEFAULT -> default [167:12]
    |       |   |           |   |   `--COLON -> : [167:19]
    |       |   |           |   `--SLIST -> SLIST [168:16]
    |       |   |           |       |--LITERAL_IF -> if [168:16]
    |       |   |           |       |   |--LPAREN -> ( [168:19]
    |       |   |           |       |   |--EXPR -> EXPR [168:20]
    |       |   |           |       |   |   `--LNOT -> ! [168:20]
    |       |   |           |       |   |       |--LPAREN -> ( [168:21]
    |       |   |           |       |   |       |--LITERAL_INSTANCEOF -> instanceof [168:25]
    |       |   |           |       |   |       |   |--IDENT -> o1 [168:22]
    |       |   |           |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [168:36]
    |       |   |           |       |   |       |       |--TYPE -> TYPE [168:36]
    |       |   |           |       |   |       |       |   `--IDENT -> String [168:36]
    |       |   |           |       |   |       |       `--IDENT -> str [168:43]
    |       |   |           |       |   |       `--RPAREN -> ) [168:46]
    |       |   |           |       |   |--RPAREN -> ) [168:47]
    |       |   |           |       |   `--SLIST -> { [168:49]
    |       |   |           |       |       |--LITERAL_YIELD -> yield [169:20]
    |       |   |           |       |       |   |--EXPR -> EXPR [169:26]
    |       |   |           |       |       |   |   `--LITERAL_FALSE -> false [169:26]
    |       |   |           |       |       |   `--SEMI -> ; [169:31]
    |       |   |           |       |       `--RCURLY -> } [170:16]
    |       |   |           |       |--LITERAL_IF -> if [171:16]
    |       |   |           |       |   |--LPAREN -> ( [171:19]
    |       |   |           |       |   |--EXPR -> EXPR [171:31]
    |       |   |           |       |   |   `--METHOD_CALL -> ( [171:31]
    |       |   |           |       |   |       |--DOT -> . [171:23]
    |       |   |           |       |   |       |   |--IDENT -> str [171:20]
    |       |   |           |       |   |       |   `--IDENT -> isEmpty [171:24]
    |       |   |           |       |   |       |--ELIST -> ELIST [171:32]
    |       |   |           |       |   |       `--RPAREN -> ) [171:32]
    |       |   |           |       |   |--RPAREN -> ) [171:33]
    |       |   |           |       |   `--SLIST -> { [171:35]
    |       |   |           |       |       |--LITERAL_YIELD -> yield [172:20]
    |       |   |           |       |       |   |--EXPR -> EXPR [172:26]
    |       |   |           |       |       |   |   `--LITERAL_TRUE -> true [172:26]
    |       |   |           |       |       |   `--SEMI -> ; [172:30]
    |       |   |           |       |       `--RCURLY -> } [173:16]
    |       |   |           |       `--LITERAL_YIELD -> yield [174:16]
    |       |   |           |           |--EXPR -> EXPR [174:22]
    |       |   |           |           |   `--LITERAL_TRUE -> true [174:22]
    |       |   |           |           `--SEMI -> ; [174:26]
    |       |   |           `--RCURLY -> } [175:8]
    |       |   |--RPAREN -> ) [175:9]
    |       |   `--SLIST -> { [175:11]
    |       |       |--LITERAL_THROW -> throw [176:12]
    |       |       |   |--EXPR -> EXPR [176:18]
    |       |       |   |   `--LITERAL_NEW -> new [176:18]
    |       |       |   |       |--IDENT -> AssertionError [176:22]
    |       |       |   |       |--LPAREN -> ( [176:36]
    |       |       |   |       |--ELIST -> ELIST [176:37]
    |       |       |   |       `--RPAREN -> ) [176:37]
    |       |       |   `--SEMI -> ; [176:38]
    |       |       `--RCURLY -> } [177:8]
    |       `--RCURLY -> } [178:4]
    |--METHOD_DEF -> METHOD_DEF [180:4]
    |   |--MODIFIERS -> MODIFIERS [180:4]
    |   |   |--LITERAL_PUBLIC -> public [180:4]
    |   |   `--LITERAL_STATIC -> static [180:11]
    |   |--TYPE -> TYPE [180:18]
    |   |   `--LITERAL_VOID -> void [180:18]
    |   |--IDENT -> main [180:23]
    |   |--LPAREN -> ( [180:27]
    |   |--PARAMETERS -> PARAMETERS [180:28]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [180:28]
    |   |       |--MODIFIERS -> MODIFIERS [180:28]
    |   |       |--TYPE -> TYPE [180:28]
    |   |       |   `--IDENT -> String [180:28]
    |   |       |--ELLIPSIS -> ... [180:34]
    |   |       `--IDENT -> args [180:38]
    |   |--RPAREN -> ) [180:42]
    |   `--SLIST -> { [180:44]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [181:8]
    |       |   |--MODIFIERS -> MODIFIERS [181:8]
    |       |   |--TYPE -> TYPE [181:8]
    |       |   |   `--IDENT -> T [181:8]
    |       |   |--IDENT -> t [181:10]
    |       |   `--ASSIGN -> = [181:12]
    |       |       `--EXPR -> EXPR [181:15]
    |       |           `--DOT -> . [181:15]
    |       |               |--IDENT -> T [181:14]
    |       |               `--IDENT -> B [181:16]
    |       |--SEMI -> ; [181:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [182:8]
    |       |   |--MODIFIERS -> MODIFIERS [182:8]
    |       |   |--TYPE -> TYPE [182:8]
    |       |   |   `--LITERAL_INT -> int [182:8]
    |       |   |--IDENT -> a [182:12]
    |       |   `--ASSIGN -> = [182:14]
    |       |       `--EXPR -> EXPR [182:16]
    |       |           `--NUM_INT -> 8 [182:16]
    |       |--SEMI -> ; [182:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [183:8]
    |       |   |--MODIFIERS -> MODIFIERS [183:8]
    |       |   |--TYPE -> TYPE [183:8]
    |       |   |   `--LITERAL_INT -> int [183:8]
    |       |   `--IDENT -> x [183:12]
    |       |--SEMI -> ; [183:13]
    |       |--EXPR -> EXPR [185:26]
    |       |   `--METHOD_CALL -> ( [185:26]
    |       |       |--DOT -> . [185:18]
    |       |       |   |--DOT -> . [185:14]
    |       |       |   |   |--IDENT -> System [185:8]
    |       |       |   |   `--IDENT -> out [185:15]
    |       |       |   `--IDENT -> println [185:19]
    |       |       |--ELIST -> ELIST [185:27]
    |       |       |   `--EXPR -> EXPR [185:27]
    |       |       |       `--STRING_LITERAL -> "works!" [185:27]
    |       |       `--RPAREN -> ) [185:35]
    |       |--SEMI -> ; [185:36]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [186:8]
    |       |   |--MODIFIERS -> MODIFIERS [186:8]
    |       |   |--TYPE -> TYPE [186:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [186:8]
    |       |   |--IDENT -> t1b [186:16]
    |       |   `--ASSIGN -> = [186:20]
    |       |       `--EXPR -> EXPR [191:11]
    |       |           `--LAND -> && [191:11]
    |       |               |--LPAREN -> ( [186:22]
    |       |               |--LITERAL_SWITCH -> switch [186:23]
    |       |               |   |--LPAREN -> ( [186:30]
    |       |               |   |--EXPR -> EXPR [186:31]
    |       |               |   |   `--IDENT -> a [186:31]
    |       |               |   |--RPAREN -> ) [186:32]
    |       |               |   |--LCURLY -> { [186:34]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [187:12]
    |       |               |   |   |--LITERAL_CASE -> case [187:12]
    |       |               |   |   |   |--EXPR -> EXPR [187:17]
    |       |               |   |   |   |   `--NUM_INT -> 0 [187:17]
    |       |               |   |   |   `--COLON -> : [187:18]
    |       |               |   |   `--SLIST -> SLIST [188:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [188:16]
    |       |               |   |           |--EXPR -> EXPR [188:30]
    |       |               |   |           |   `--EQUAL -> == [188:30]
    |       |               |   |           |       |--LPAREN -> ( [188:22]
    |       |               |   |           |       |--ASSIGN -> = [188:25]
    |       |               |   |           |       |   |--IDENT -> x [188:23]
    |       |               |   |           |       |   `--NUM_INT -> 1 [188:27]
    |       |               |   |           |       |--RPAREN -> ) [188:28]
    |       |               |   |           |       `--NUM_INT -> 1 [188:33]
    |       |               |   |           `--SEMI -> ; [188:34]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [189:12]
    |       |               |   |   |--LITERAL_DEFAULT -> default [189:12]
    |       |               |   |   |   `--COLON -> : [189:19]
    |       |               |   |   `--SLIST -> SLIST [190:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [190:16]
    |       |               |   |           |--EXPR -> EXPR [190:22]
    |       |               |   |           |   `--LITERAL_FALSE -> false [190:22]
    |       |               |   |           `--SEMI -> ; [190:27]
    |       |               |   `--RCURLY -> } [191:8]
    |       |               |--RPAREN -> ) [191:9]
    |       |               `--EQUAL -> == [191:16]
    |       |                   |--IDENT -> x [191:14]
    |       |                   `--NUM_INT -> 1 [191:19]
    |       |--SEMI -> ; [191:20]
    |       |--LITERAL_TRY -> try [193:8]
    |       |   |--SLIST -> { [193:12]
    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [194:12]
    |       |   |   |   |--MODIFIERS -> MODIFIERS [194:12]
    |       |   |   |   |--TYPE -> TYPE [194:12]
    |       |   |   |   |   `--LITERAL_INT -> int [194:12]
    |       |   |   |   |--IDENT -> ii [194:16]
    |       |   |   |   `--ASSIGN -> = [194:19]
    |       |   |   |       `--EXPR -> EXPR [194:21]
    |       |   |   |           `--LITERAL_SWITCH -> switch [194:21]
    |       |   |   |               |--LPAREN -> ( [194:28]
    |       |   |   |               |--EXPR -> EXPR [194:29]
    |       |   |   |               |   `--IDENT -> t [194:29]
    |       |   |   |               |--RPAREN -> ) [194:30]
    |       |   |   |               |--LCURLY -> { [194:32]
    |       |   |   |               |--SWITCH_RULE -> SWITCH_RULE [195:16]
    |       |   |   |               |   |--LITERAL_CASE -> case [195:16]
    |       |   |   |               |   |   `--EXPR -> EXPR [195:21]
    |       |   |   |               |   |       `--IDENT -> A [195:21]
    |       |   |   |               |   |--LAMBDA -> -> [195:23]
    |       |   |   |               |   |--EXPR -> EXPR [195:26]
    |       |   |   |               |   |   `--NUM_INT -> 0 [195:26]
    |       |   |   |               |   `--SEMI -> ; [195:27]
    |       |   |   |               |--SWITCH_RULE -> SWITCH_RULE [196:16]
    |       |   |   |               |   |--LITERAL_DEFAULT -> default [196:16]
    |       |   |   |               |   |--LAMBDA -> -> [196:24]
    |       |   |   |               |   `--LITERAL_THROW -> throw [196:27]
    |       |   |   |               |       |--EXPR -> EXPR [196:33]
    |       |   |   |               |       |   `--LITERAL_NEW -> new [196:33]
    |       |   |   |               |       |       |--IDENT -> IllegalStateException [196:37]
    |       |   |   |               |       |       |--LPAREN -> ( [196:58]
    |       |   |   |               |       |       |--ELIST -> ELIST [196:59]
    |       |   |   |               |       |       `--RPAREN -> ) [196:59]
    |       |   |   |               |       `--SEMI -> ; [196:60]
    |       |   |   |               `--RCURLY -> } [197:12]
    |       |   |   |--SEMI -> ; [197:13]
    |       |   |   |--LITERAL_THROW -> throw [198:12]
    |       |   |   |   |--EXPR -> EXPR [198:18]
    |       |   |   |   |   `--LITERAL_NEW -> new [198:18]
    |       |   |   |   |       |--IDENT -> AssertionError [198:22]
    |       |   |   |   |       |--LPAREN -> ( [198:36]
    |       |   |   |   |       |--ELIST -> ELIST [198:37]
    |       |   |   |   |       |   `--EXPR -> EXPR [198:37]
    |       |   |   |   |       |       `--STRING_LITERAL -> "Expected exception not thrown." [198:37]
    |       |   |   |   |       `--RPAREN -> ) [198:69]
    |       |   |   |   `--SEMI -> ; [198:70]
    |       |   |   `--RCURLY -> } [199:8]
    |       |   `--LITERAL_CATCH -> catch [199:10]
    |       |       |--LPAREN -> ( [199:16]
    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [199:17]
    |       |       |   |--MODIFIERS -> MODIFIERS [199:17]
    |       |       |   |--TYPE -> TYPE [199:17]
    |       |       |   |   `--IDENT -> IllegalStateException [199:17]
    |       |       |   `--IDENT -> ex [199:39]
    |       |       |--RPAREN -> ) [199:41]
    |       |       `--SLIST -> { [199:43]
    |       |           `--RCURLY -> } [201:8]
    |       `--RCURLY -> } [202:4]
    |--ENUM_DEF -> ENUM_DEF [204:4]
    |   |--MODIFIERS -> MODIFIERS [204:4]
    |   |--ENUM -> enum [204:4]
    |   |--IDENT -> T [204:9]
    |   `--OBJBLOCK -> OBJBLOCK [204:11]
    |       |--LCURLY -> { [204:11]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [205:8]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [205:8]
    |       |   `--IDENT -> A [205:8]
    |       |--COMMA -> , [205:9]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [205:11]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [205:11]
    |       |   `--IDENT -> B [205:11]
    |       |--COMMA -> , [205:12]
    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [205:14]
    |       |   |--ANNOTATIONS -> ANNOTATIONS [205:14]
    |       |   `--IDENT -> C [205:14]
    |       |--SEMI -> ; [205:15]
    |       `--RCURLY -> } [206:4]
    |--METHOD_DEF -> METHOD_DEF [208:4]
    |   |--MODIFIERS -> MODIFIERS [208:4]
    |   |   |--LITERAL_PRIVATE -> private [208:4]
    |   |   `--LITERAL_STATIC -> static [208:12]
    |   |--TYPE -> TYPE [208:19]
    |   |   `--LITERAL_BOOLEAN -> boolean [208:19]
    |   |--IDENT -> isTrue [208:27]
    |   |--LPAREN -> ( [208:33]
    |   |--PARAMETERS -> PARAMETERS [208:34]
    |   |--RPAREN -> ) [208:34]
    |   `--SLIST -> { [208:36]
    |       |--LITERAL_RETURN -> return [209:8]
    |       |   |--EXPR -> EXPR [209:15]
    |       |   |   `--LITERAL_TRUE -> true [209:15]
    |       |   `--SEMI -> ; [209:19]
    |       `--RCURLY -> } [210:4]
    |--STATIC_INIT -> STATIC_INIT [212:4]
    |   `--SLIST -> { [212:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [213:8]
    |       |   |--MODIFIERS -> MODIFIERS [213:8]
    |       |   |--TYPE -> TYPE [213:8]
    |       |   |   `--LITERAL_INT -> int [213:8]
    |       |   `--IDENT -> x [213:12]
    |       |--SEMI -> ; [213:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [215:8]
    |       |   |--MODIFIERS -> MODIFIERS [215:8]
    |       |   |--TYPE -> TYPE [215:8]
    |       |   |   `--LITERAL_INT -> int [215:8]
    |       |   |--IDENT -> t7 [215:12]
    |       |   `--ASSIGN -> = [215:15]
    |       |       `--EXPR -> EXPR [215:45]
    |       |           `--METHOD_CALL -> ( [215:45]
    |       |               |--DOT -> . [215:42]
    |       |               |   |--LITERAL_NEW -> new [215:17]
    |       |               |   |   |--IDENT -> DefiniteAssignment1 [215:21]
    |       |               |   |   |--LPAREN -> ( [215:40]
    |       |               |   |   |--ELIST -> ELIST [215:41]
    |       |               |   |   `--RPAREN -> ) [215:41]
    |       |               |   `--IDENT -> id [215:43]
    |       |               |--ELIST -> ELIST [217:36]
    |       |               |   `--EXPR -> EXPR [217:36]
    |       |               |       `--QUESTION -> ? [217:36]
    |       |               |           |--LAND -> && [217:26]
    |       |               |           |   |--LAND -> && [217:10]
    |       |               |           |   |   |--LITERAL_SWITCH -> switch [215:46]
    |       |               |           |   |   |   |--LPAREN -> ( [215:53]
    |       |               |           |   |   |   |--EXPR -> EXPR [215:54]
    |       |               |           |   |   |   |   `--NUM_INT -> 0 [215:54]
    |       |               |           |   |   |   |--RPAREN -> ) [215:55]
    |       |               |           |   |   |   |--LCURLY -> { [215:57]
    |       |               |           |   |   |   |--SWITCH_RULE -> SWITCH_RULE [216:12]
    |       |               |           |   |   |   |   |--LITERAL_DEFAULT -> default [216:12]
    |       |               |           |   |   |   |   |--LAMBDA -> -> [216:20]
    |       |               |           |   |   |   |   |--EXPR -> EXPR [216:29]
    |       |               |           |   |   |   |   |   `--METHOD_CALL -> ( [216:29]
    |       |               |           |   |   |   |   |       |--IDENT -> isTrue [216:23]
    |       |               |           |   |   |   |   |       |--ELIST -> ELIST [216:30]
    |       |               |           |   |   |   |   |       `--RPAREN -> ) [216:30]
    |       |               |           |   |   |   |   `--SEMI -> ; [216:31]
    |       |               |           |   |   |   `--RCURLY -> } [217:8]
    |       |               |           |   |   `--EQUAL -> == [217:21]
    |       |               |           |   |       |--LPAREN -> ( [217:13]
    |       |               |           |   |       |--ASSIGN -> = [217:16]
    |       |               |           |   |       |   |--IDENT -> x [217:14]
    |       |               |           |   |       |   `--NUM_INT -> 1 [217:18]
    |       |               |           |   |       |--RPAREN -> ) [217:19]
    |       |               |           |   |       `--NUM_INT -> 1 [217:24]
    |       |               |           |   `--EQUAL -> == [217:31]
    |       |               |           |       |--IDENT -> x [217:29]
    |       |               |           |       `--NUM_INT -> 1 [217:34]
    |       |               |           |--NUM_INT -> 2 [217:38]
    |       |               |           |--COLON -> : [217:40]
    |       |               |           `--UNARY_MINUS -> - [217:42]
    |       |               |               `--NUM_INT -> 1 [217:43]
    |       |               `--RPAREN -> ) [217:44]
    |       |--SEMI -> ; [217:45]
    |       |--LITERAL_IF -> if [219:8]
    |       |   |--LPAREN -> ( [219:11]
    |       |   |--EXPR -> EXPR [219:15]
    |       |   |   `--NOT_EQUAL -> != [219:15]
    |       |   |       |--IDENT -> t7 [219:12]
    |       |   |       `--NUM_INT -> 2 [219:18]
    |       |   |--RPAREN -> ) [219:19]
    |       |   `--SLIST -> { [219:21]
    |       |       |--LITERAL_THROW -> throw [220:12]
    |       |       |   |--EXPR -> EXPR [220:18]
    |       |       |   |   `--LITERAL_NEW -> new [220:18]
    |       |       |   |       |--IDENT -> IllegalStateException [220:22]
    |       |       |   |       |--LPAREN -> ( [220:43]
    |       |       |   |       |--ELIST -> ELIST [220:44]
    |       |       |   |       |   `--EXPR -> EXPR [220:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [220:44]
    |       |       |   |       `--RPAREN -> ) [220:64]
    |       |       |   `--SEMI -> ; [220:65]
    |       |       `--RCURLY -> } [221:8]
    |       `--RCURLY -> } [222:4]
    |--STATIC_INIT -> STATIC_INIT [224:4]
    |   `--SLIST -> { [224:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [225:8]
    |       |   |--MODIFIERS -> MODIFIERS [225:8]
    |       |   |--TYPE -> TYPE [225:8]
    |       |   |   `--LITERAL_INT -> int [225:8]
    |       |   `--IDENT -> x [225:12]
    |       |--SEMI -> ; [225:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [226:8]
    |       |   |--MODIFIERS -> MODIFIERS [226:8]
    |       |   |--TYPE -> TYPE [226:8]
    |       |   |   `--IDENT -> T [226:8]
    |       |   |--IDENT -> e [226:10]
    |       |   `--ASSIGN -> = [226:12]
    |       |       `--EXPR -> EXPR [226:15]
    |       |           `--DOT -> . [226:15]
    |       |               |--IDENT -> T [226:14]
    |       |               `--IDENT -> B [226:16]
    |       |--SEMI -> ; [226:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [228:8]
    |       |   |--MODIFIERS -> MODIFIERS [228:8]
    |       |   |--TYPE -> TYPE [228:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [228:8]
    |       |   |--IDENT -> t8 [228:16]
    |       |   `--ASSIGN -> = [228:19]
    |       |       `--EXPR -> EXPR [236:11]
    |       |           `--LAND -> && [236:11]
    |       |               |--LPAREN -> ( [228:21]
    |       |               |--LITERAL_SWITCH -> switch [228:22]
    |       |               |   |--LPAREN -> ( [228:29]
    |       |               |   |--EXPR -> EXPR [228:30]
    |       |               |   |   `--IDENT -> e [228:30]
    |       |               |   |--RPAREN -> ) [228:31]
    |       |               |   |--LCURLY -> { [228:33]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [229:12]
    |       |               |   |   |--LITERAL_CASE -> case [229:12]
    |       |               |   |   |   |--EXPR -> EXPR [229:17]
    |       |               |   |   |   |   `--IDENT -> A [229:17]
    |       |               |   |   |   `--COLON -> : [229:18]
    |       |               |   |   `--SLIST -> SLIST [230:18]
    |       |               |   |       |--EXPR -> EXPR [230:18]
    |       |               |   |       |   `--ASSIGN -> = [230:18]
    |       |               |   |       |       |--IDENT -> x [230:16]
    |       |               |   |       |       `--NUM_INT -> 1 [230:20]
    |       |               |   |       |--SEMI -> ; [230:21]
    |       |               |   |       `--LITERAL_YIELD -> yield [231:16]
    |       |               |   |           |--EXPR -> EXPR [231:22]
    |       |               |   |           |   `--LITERAL_TRUE -> true [231:22]
    |       |               |   |           `--SEMI -> ; [231:26]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [232:12]
    |       |               |   |   |--LITERAL_CASE -> case [232:12]
    |       |               |   |   |   |--EXPR -> EXPR [232:17]
    |       |               |   |   |   |   `--IDENT -> B [232:17]
    |       |               |   |   |   `--COLON -> : [232:18]
    |       |               |   |   `--SLIST -> SLIST [233:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [233:16]
    |       |               |   |           |--EXPR -> EXPR [233:35]
    |       |               |   |           |   `--LOR -> || [233:35]
    |       |               |   |           |       |--EQUAL -> == [233:30]
    |       |               |   |           |       |   |--LPAREN -> ( [233:22]
    |       |               |   |           |       |   |--ASSIGN -> = [233:25]
    |       |               |   |           |       |   |   |--IDENT -> x [233:23]
    |       |               |   |           |       |   |   `--NUM_INT -> 1 [233:27]
    |       |               |   |           |       |   |--RPAREN -> ) [233:28]
    |       |               |   |           |       |   `--NUM_INT -> 1 [233:33]
    |       |               |   |           |       `--LITERAL_TRUE -> true [233:38]
    |       |               |   |           `--SEMI -> ; [233:42]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [234:12]
    |       |               |   |   |--LITERAL_DEFAULT -> default [234:12]
    |       |               |   |   |   `--COLON -> : [234:19]
    |       |               |   |   `--SLIST -> SLIST [235:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [235:16]
    |       |               |   |           |--EXPR -> EXPR [235:22]
    |       |               |   |           |   `--LITERAL_FALSE -> false [235:22]
    |       |               |   |           `--SEMI -> ; [235:27]
    |       |               |   `--RCURLY -> } [236:8]
    |       |               |--RPAREN -> ) [236:9]
    |       |               `--EQUAL -> == [236:16]
    |       |                   |--IDENT -> x [236:14]
    |       |                   `--NUM_INT -> 1 [236:19]
    |       |--SEMI -> ; [236:20]
    |       |--LITERAL_IF -> if [238:8]
    |       |   |--LPAREN -> ( [238:11]
    |       |   |--EXPR -> EXPR [238:12]
    |       |   |   `--LNOT -> ! [238:12]
    |       |   |       `--IDENT -> t8 [238:13]
    |       |   |--RPAREN -> ) [238:15]
    |       |   `--SLIST -> { [238:17]
    |       |       |--LITERAL_THROW -> throw [239:12]
    |       |       |   |--EXPR -> EXPR [239:18]
    |       |       |   |   `--LITERAL_NEW -> new [239:18]
    |       |       |   |       |--IDENT -> IllegalStateException [239:22]
    |       |       |   |       |--LPAREN -> ( [239:43]
    |       |       |   |       |--ELIST -> ELIST [239:44]
    |       |       |   |       |   `--EXPR -> EXPR [239:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [239:44]
    |       |       |   |       `--RPAREN -> ) [239:64]
    |       |       |   `--SEMI -> ; [239:65]
    |       |       `--RCURLY -> } [240:8]
    |       `--RCURLY -> } [241:4]
    |--STATIC_INIT -> STATIC_INIT [243:4]
    |   `--SLIST -> { [243:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [244:8]
    |       |   |--MODIFIERS -> MODIFIERS [244:8]
    |       |   |--TYPE -> TYPE [244:8]
    |       |   |   `--LITERAL_INT -> int [244:8]
    |       |   `--IDENT -> x [244:12]
    |       |--SEMI -> ; [244:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [245:8]
    |       |   |--MODIFIERS -> MODIFIERS [245:8]
    |       |   |--TYPE -> TYPE [245:8]
    |       |   |   `--IDENT -> T [245:8]
    |       |   |--IDENT -> e [245:10]
    |       |   `--ASSIGN -> = [245:12]
    |       |       `--EXPR -> EXPR [245:15]
    |       |           `--DOT -> . [245:15]
    |       |               |--IDENT -> T [245:14]
    |       |               `--IDENT -> B [245:16]
    |       |--SEMI -> ; [245:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [247:8]
    |       |   |--MODIFIERS -> MODIFIERS [247:8]
    |       |   |--TYPE -> TYPE [247:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [247:8]
    |       |   |--IDENT -> t8 [247:16]
    |       |   `--ASSIGN -> = [247:19]
    |       |       `--EXPR -> EXPR [255:11]
    |       |           `--LAND -> && [255:11]
    |       |               |--LPAREN -> ( [247:21]
    |       |               |--LITERAL_SWITCH -> switch [247:22]
    |       |               |   |--LPAREN -> ( [247:29]
    |       |               |   |--EXPR -> EXPR [247:30]
    |       |               |   |   `--IDENT -> e [247:30]
    |       |               |   |--RPAREN -> ) [247:31]
    |       |               |   |--LCURLY -> { [247:33]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [248:12]
    |       |               |   |   |--LITERAL_CASE -> case [248:12]
    |       |               |   |   |   |--EXPR -> EXPR [248:17]
    |       |               |   |   |   |   `--IDENT -> A [248:17]
    |       |               |   |   |   `--COLON -> : [248:18]
    |       |               |   |   `--SLIST -> SLIST [249:18]
    |       |               |   |       |--EXPR -> EXPR [249:18]
    |       |               |   |       |   `--ASSIGN -> = [249:18]
    |       |               |   |       |       |--IDENT -> x [249:16]
    |       |               |   |       |       `--NUM_INT -> 1 [249:20]
    |       |               |   |       |--SEMI -> ; [249:21]
    |       |               |   |       `--LITERAL_YIELD -> yield [250:16]
    |       |               |   |           |--EXPR -> EXPR [250:28]
    |       |               |   |           |   `--METHOD_CALL -> ( [250:28]
    |       |               |   |           |       |--IDENT -> isTrue [250:22]
    |       |               |   |           |       |--ELIST -> ELIST [250:29]
    |       |               |   |           |       `--RPAREN -> ) [250:29]
    |       |               |   |           `--SEMI -> ; [250:30]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [251:12]
    |       |               |   |   |--LITERAL_CASE -> case [251:12]
    |       |               |   |   |   |--EXPR -> EXPR [251:17]
    |       |               |   |   |   |   `--IDENT -> B [251:17]
    |       |               |   |   |   `--COLON -> : [251:18]
    |       |               |   |   `--SLIST -> SLIST [252:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [252:16]
    |       |               |   |           |--EXPR -> EXPR [252:35]
    |       |               |   |           |   `--LOR -> || [252:35]
    |       |               |   |           |       |--EQUAL -> == [252:30]
    |       |               |   |           |       |   |--LPAREN -> ( [252:22]
    |       |               |   |           |       |   |--ASSIGN -> = [252:25]
    |       |               |   |           |       |   |   |--IDENT -> x [252:23]
    |       |               |   |           |       |   |   `--NUM_INT -> 1 [252:27]
    |       |               |   |           |       |   |--RPAREN -> ) [252:28]
    |       |               |   |           |       |   `--NUM_INT -> 1 [252:33]
    |       |               |   |           |       `--METHOD_CALL -> ( [252:44]
    |       |               |   |           |           |--IDENT -> isTrue [252:38]
    |       |               |   |           |           |--ELIST -> ELIST [252:45]
    |       |               |   |           |           `--RPAREN -> ) [252:45]
    |       |               |   |           `--SEMI -> ; [252:46]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [253:12]
    |       |               |   |   |--LITERAL_DEFAULT -> default [253:12]
    |       |               |   |   |   `--COLON -> : [253:19]
    |       |               |   |   `--SLIST -> SLIST [254:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [254:16]
    |       |               |   |           |--EXPR -> EXPR [254:22]
    |       |               |   |           |   `--LITERAL_FALSE -> false [254:22]
    |       |               |   |           `--SEMI -> ; [254:27]
    |       |               |   `--RCURLY -> } [255:8]
    |       |               |--RPAREN -> ) [255:9]
    |       |               `--EQUAL -> == [255:16]
    |       |                   |--IDENT -> x [255:14]
    |       |                   `--NUM_INT -> 1 [255:19]
    |       |--SEMI -> ; [255:20]
    |       |--LITERAL_IF -> if [257:8]
    |       |   |--LPAREN -> ( [257:11]
    |       |   |--EXPR -> EXPR [257:12]
    |       |   |   `--LNOT -> ! [257:12]
    |       |   |       `--IDENT -> t8 [257:13]
    |       |   |--RPAREN -> ) [257:15]
    |       |   `--SLIST -> { [257:17]
    |       |       |--LITERAL_THROW -> throw [258:12]
    |       |       |   |--EXPR -> EXPR [258:18]
    |       |       |   |   `--LITERAL_NEW -> new [258:18]
    |       |       |   |       |--IDENT -> IllegalStateException [258:22]
    |       |       |   |       |--LPAREN -> ( [258:43]
    |       |       |   |       |--ELIST -> ELIST [258:44]
    |       |       |   |       |   `--EXPR -> EXPR [258:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [258:44]
    |       |       |   |       `--RPAREN -> ) [258:64]
    |       |       |   `--SEMI -> ; [258:65]
    |       |       `--RCURLY -> } [259:8]
    |       |--SLIST -> { [261:8]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [262:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [262:12]
    |       |   |   |--TYPE -> TYPE [262:12]
    |       |   |   |   `--IDENT -> T [262:12]
    |       |   |   |--IDENT -> y [262:14]
    |       |   |   `--ASSIGN -> = [262:16]
    |       |   |       `--EXPR -> EXPR [262:19]
    |       |   |           `--DOT -> . [262:19]
    |       |   |               |--IDENT -> T [262:18]
    |       |   |               `--IDENT -> A [262:20]
    |       |   |--SEMI -> ; [262:21]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [264:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [264:12]
    |       |   |   |--TYPE -> TYPE [264:12]
    |       |   |   |   `--LITERAL_BOOLEAN -> boolean [264:12]
    |       |   |   |--IDENT -> t9 [264:20]
    |       |   |   `--ASSIGN -> = [264:23]
    |       |   |       `--EXPR -> EXPR [272:15]
    |       |   |           `--LAND -> && [272:15]
    |       |   |               |--LPAREN -> ( [264:25]
    |       |   |               |--LITERAL_SWITCH -> switch [264:26]
    |       |   |               |   |--LPAREN -> ( [264:33]
    |       |   |               |   |--EXPR -> EXPR [264:34]
    |       |   |               |   |   `--IDENT -> y [264:34]
    |       |   |               |   |--RPAREN -> ) [264:35]
    |       |   |               |   |--LCURLY -> { [264:37]
    |       |   |               |   |--CASE_GROUP -> CASE_GROUP [265:16]
    |       |   |               |   |   |--LITERAL_CASE -> case [265:16]
    |       |   |               |   |   |   |--EXPR -> EXPR [265:21]
    |       |   |               |   |   |   |   `--IDENT -> A [265:21]
    |       |   |               |   |   |   `--COLON -> : [265:22]
    |       |   |               |   |   `--SLIST -> SLIST [266:22]
    |       |   |               |   |       |--EXPR -> EXPR [266:22]
    |       |   |               |   |       |   `--ASSIGN -> = [266:22]
    |       |   |               |   |       |       |--IDENT -> x [266:20]
    |       |   |               |   |       |       `--NUM_INT -> 1 [266:24]
    |       |   |               |   |       |--SEMI -> ; [266:25]
    |       |   |               |   |       `--LITERAL_YIELD -> yield [267:20]
    |       |   |               |   |           |--EXPR -> EXPR [267:26]
    |       |   |               |   |           |   `--LITERAL_TRUE -> true [267:26]
    |       |   |               |   |           `--SEMI -> ; [267:30]
    |       |   |               |   |--CASE_GROUP -> CASE_GROUP [268:16]
    |       |   |               |   |   |--LITERAL_CASE -> case [268:16]
    |       |   |               |   |   |   |--EXPR -> EXPR [268:21]
    |       |   |               |   |   |   |   `--IDENT -> B [268:21]
    |       |   |               |   |   |   `--COLON -> : [268:22]
    |       |   |               |   |   `--SLIST -> SLIST [269:20]
    |       |   |               |   |       `--LITERAL_YIELD -> yield [269:20]
    |       |   |               |   |           |--EXPR -> EXPR [269:39]
    |       |   |               |   |           |   `--LOR -> || [269:39]
    |       |   |               |   |           |       |--EQUAL -> == [269:34]
    |       |   |               |   |           |       |   |--LPAREN -> ( [269:26]
    |       |   |               |   |           |       |   |--ASSIGN -> = [269:29]
    |       |   |               |   |           |       |   |   |--IDENT -> x [269:27]
    |       |   |               |   |           |       |   |   `--NUM_INT -> 1 [269:31]
    |       |   |               |   |           |       |   |--RPAREN -> ) [269:32]
    |       |   |               |   |           |       |   `--NUM_INT -> 1 [269:37]
    |       |   |               |   |           |       `--LITERAL_TRUE -> true [269:42]
    |       |   |               |   |           `--SEMI -> ; [269:46]
    |       |   |               |   |--CASE_GROUP -> CASE_GROUP [270:16]
    |       |   |               |   |   |--LITERAL_DEFAULT -> default [270:16]
    |       |   |               |   |   |   `--COLON -> : [270:23]
    |       |   |               |   |   `--SLIST -> SLIST [271:20]
    |       |   |               |   |       `--LITERAL_YIELD -> yield [271:20]
    |       |   |               |   |           |--EXPR -> EXPR [271:26]
    |       |   |               |   |           |   `--LITERAL_FALSE -> false [271:26]
    |       |   |               |   |           `--SEMI -> ; [271:31]
    |       |   |               |   `--RCURLY -> } [272:12]
    |       |   |               |--RPAREN -> ) [272:13]
    |       |   |               `--EQUAL -> == [272:20]
    |       |   |                   |--IDENT -> x [272:18]
    |       |   |                   `--NUM_INT -> 1 [272:23]
    |       |   |--SEMI -> ; [272:24]
    |       |   |--LITERAL_IF -> if [274:12]
    |       |   |   |--LPAREN -> ( [274:15]
    |       |   |   |--EXPR -> EXPR [274:16]
    |       |   |   |   `--LNOT -> ! [274:16]
    |       |   |   |       `--IDENT -> t9 [274:17]
    |       |   |   |--RPAREN -> ) [274:19]
    |       |   |   `--SLIST -> { [274:21]
    |       |   |       |--LITERAL_THROW -> throw [275:16]
    |       |   |       |   |--EXPR -> EXPR [275:22]
    |       |   |       |   |   `--LITERAL_NEW -> new [275:22]
    |       |   |       |   |       |--IDENT -> IllegalStateException [275:26]
    |       |   |       |   |       |--LPAREN -> ( [275:47]
    |       |   |       |   |       |--ELIST -> ELIST [275:48]
    |       |   |       |   |       |   `--EXPR -> EXPR [275:48]
    |       |   |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [275:48]
    |       |   |       |   |       `--RPAREN -> ) [275:68]
    |       |   |       |   `--SEMI -> ; [275:69]
    |       |   |       `--RCURLY -> } [276:12]
    |       |   `--RCURLY -> } [277:8]
    |       |--SLIST -> { [280:8]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [281:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [281:12]
    |       |   |   |--TYPE -> TYPE [281:12]
    |       |   |   |   `--IDENT -> T [281:12]
    |       |   |   |--IDENT -> y [281:14]
    |       |   |   `--ASSIGN -> = [281:16]
    |       |   |       `--EXPR -> EXPR [281:19]
    |       |   |           `--DOT -> . [281:19]
    |       |   |               |--IDENT -> T [281:18]
    |       |   |               `--IDENT -> A [281:20]
    |       |   |--SEMI -> ; [281:21]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [283:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [283:12]
    |       |   |   |--TYPE -> TYPE [283:12]
    |       |   |   |   `--LITERAL_INT -> int [283:12]
    |       |   |   |--IDENT -> v [283:16]
    |       |   |   `--ASSIGN -> = [283:18]
    |       |   |       `--EXPR -> EXPR [283:20]
    |       |   |           `--LITERAL_SWITCH -> switch [283:20]
    |       |   |               |--LPAREN -> ( [283:27]
    |       |   |               |--EXPR -> EXPR [283:28]
    |       |   |               |   `--IDENT -> y [283:28]
    |       |   |               |--RPAREN -> ) [283:29]
    |       |   |               |--LCURLY -> { [283:31]
    |       |   |               |--SWITCH_RULE -> SWITCH_RULE [284:16]
    |       |   |               |   |--LITERAL_CASE -> case [284:16]
    |       |   |               |   |   `--EXPR -> EXPR [284:21]
    |       |   |               |   |       `--IDENT -> A [284:21]
    |       |   |               |   |--LAMBDA -> -> [284:23]
    |       |   |               |   |--EXPR -> EXPR [284:28]
    |       |   |               |   |   `--ASSIGN -> = [284:28]
    |       |   |               |   |       |--IDENT -> x [284:26]
    |       |   |               |   |       `--NUM_INT -> 0 [284:30]
    |       |   |               |   `--SEMI -> ; [284:31]
    |       |   |               |--SWITCH_RULE -> SWITCH_RULE [285:16]
    |       |   |               |   |--LITERAL_CASE -> case [285:16]
    |       |   |               |   |   `--EXPR -> EXPR [285:21]
    |       |   |               |   |       `--IDENT -> B [285:21]
    |       |   |               |   |--LAMBDA -> -> [285:23]
    |       |   |               |   |--EXPR -> EXPR [285:28]
    |       |   |               |   |   `--ASSIGN -> = [285:28]
    |       |   |               |   |       |--IDENT -> x [285:26]
    |       |   |               |   |       `--NUM_INT -> 0 [285:30]
    |       |   |               |   `--SEMI -> ; [285:31]
    |       |   |               |--SWITCH_RULE -> SWITCH_RULE [286:16]
    |       |   |               |   |--LITERAL_CASE -> case [286:16]
    |       |   |               |   |   `--EXPR -> EXPR [286:21]
    |       |   |               |   |       `--IDENT -> C [286:21]
    |       |   |               |   |--LAMBDA -> -> [286:23]
    |       |   |               |   |--EXPR -> EXPR [286:28]
    |       |   |               |   |   `--ASSIGN -> = [286:28]
    |       |   |               |   |       |--IDENT -> x [286:26]
    |       |   |               |   |       `--NUM_INT -> 0 [286:30]
    |       |   |               |   `--SEMI -> ; [286:31]
    |       |   |               `--RCURLY -> } [287:12]
    |       |   |--SEMI -> ; [287:13]
    |       |   |--LITERAL_IF -> if [289:12]
    |       |   |   |--LPAREN -> ( [289:15]
    |       |   |   |--EXPR -> EXPR [289:23]
    |       |   |   |   `--LOR -> || [289:23]
    |       |   |   |       |--NOT_EQUAL -> != [289:18]
    |       |   |   |       |   |--IDENT -> x [289:16]
    |       |   |   |       |   `--NUM_INT -> 0 [289:21]
    |       |   |   |       `--NOT_EQUAL -> != [289:28]
    |       |   |   |           |--IDENT -> v [289:26]
    |       |   |   |           `--NUM_INT -> 0 [289:31]
    |       |   |   |--RPAREN -> ) [289:32]
    |       |   |   `--SLIST -> { [289:34]
    |       |   |       |--LITERAL_THROW -> throw [290:16]
    |       |   |       |   |--EXPR -> EXPR [290:22]
    |       |   |       |   |   `--LITERAL_NEW -> new [290:22]
    |       |   |       |   |       |--IDENT -> IllegalStateException [290:26]
    |       |   |       |   |       |--LPAREN -> ( [290:47]
    |       |   |       |   |       |--ELIST -> ELIST [290:48]
    |       |   |       |   |       |   `--EXPR -> EXPR [290:48]
    |       |   |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [290:48]
    |       |   |       |   |       `--RPAREN -> ) [290:68]
    |       |   |       |   `--SEMI -> ; [290:69]
    |       |   |       `--RCURLY -> } [291:12]
    |       |   `--RCURLY -> } [292:8]
    |       |--SLIST -> { [294:8]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [295:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [295:12]
    |       |   |   |--TYPE -> TYPE [295:12]
    |       |   |   |   `--IDENT -> T [295:12]
    |       |   |   |--IDENT -> y [295:14]
    |       |   |   `--ASSIGN -> = [295:16]
    |       |   |       `--EXPR -> EXPR [295:19]
    |       |   |           `--DOT -> . [295:19]
    |       |   |               |--IDENT -> T [295:18]
    |       |   |               `--IDENT -> A [295:20]
    |       |   |--SEMI -> ; [295:21]
    |       |   |--VARIABLE_DEF -> VARIABLE_DEF [297:12]
    |       |   |   |--MODIFIERS -> MODIFIERS [297:12]
    |       |   |   |--TYPE -> TYPE [297:12]
    |       |   |   |   `--LITERAL_BOOLEAN -> boolean [297:12]
    |       |   |   |--IDENT -> tA [297:20]
    |       |   |   `--ASSIGN -> = [297:23]
    |       |   |       `--EXPR -> EXPR [310:15]
    |       |   |           `--LAND -> && [310:15]
    |       |   |               |--LPAREN -> ( [297:25]
    |       |   |               |--LITERAL_SWITCH -> switch [297:26]
    |       |   |               |   |--LPAREN -> ( [297:33]
    |       |   |               |   |--EXPR -> EXPR [297:34]
    |       |   |               |   |   `--IDENT -> y [297:34]
    |       |   |               |   |--RPAREN -> ) [297:35]
    |       |   |               |   |--LCURLY -> { [297:37]
    |       |   |               |   |--SWITCH_RULE -> SWITCH_RULE [298:16]
    |       |   |               |   |   |--LITERAL_CASE -> case [298:16]
    |       |   |               |   |   |   `--EXPR -> EXPR [298:21]
    |       |   |               |   |   |       `--IDENT -> A [298:21]
    |       |   |               |   |   |--LAMBDA -> -> [298:23]
    |       |   |               |   |   `--SLIST -> { [298:26]
    |       |   |               |   |       |--EXPR -> EXPR [299:22]
    |       |   |               |   |       |   `--ASSIGN -> = [299:22]
    |       |   |               |   |       |       |--IDENT -> x [299:20]
    |       |   |               |   |       |       `--NUM_INT -> 1 [299:24]
    |       |   |               |   |       |--SEMI -> ; [299:25]
    |       |   |               |   |       |--LITERAL_YIELD -> yield [300:20]
    |       |   |               |   |       |   |--EXPR -> EXPR [300:26]
    |       |   |               |   |       |   |   `--LITERAL_TRUE -> true [300:26]
    |       |   |               |   |       |   `--SEMI -> ; [300:30]
    |       |   |               |   |       `--RCURLY -> } [301:16]
    |       |   |               |   |--SWITCH_RULE -> SWITCH_RULE [302:16]
    |       |   |               |   |   |--LITERAL_CASE -> case [302:16]
    |       |   |               |   |   |   `--EXPR -> EXPR [302:21]
    |       |   |               |   |   |       `--IDENT -> B [302:21]
    |       |   |               |   |   |--LAMBDA -> -> [302:23]
    |       |   |               |   |   `--SLIST -> { [302:26]
    |       |   |               |   |       |--EXPR -> EXPR [303:22]
    |       |   |               |   |       |   `--ASSIGN -> = [303:22]
    |       |   |               |   |       |       |--IDENT -> x [303:20]
    |       |   |               |   |       |       `--NUM_INT -> 1 [303:24]
    |       |   |               |   |       |--SEMI -> ; [303:25]
    |       |   |               |   |       |--LITERAL_YIELD -> yield [304:20]
    |       |   |               |   |       |   |--EXPR -> EXPR [304:26]
    |       |   |               |   |       |   |   `--LITERAL_TRUE -> true [304:26]
    |       |   |               |   |       |   `--SEMI -> ; [304:30]
    |       |   |               |   |       `--RCURLY -> } [305:16]
    |       |   |               |   |--SWITCH_RULE -> SWITCH_RULE [306:16]
    |       |   |               |   |   |--LITERAL_CASE -> case [306:16]
    |       |   |               |   |   |   `--EXPR -> EXPR [306:21]
    |       |   |               |   |   |       `--IDENT -> C [306:21]
    |       |   |               |   |   |--LAMBDA -> -> [306:23]
    |       |   |               |   |   `--SLIST -> { [306:26]
    |       |   |               |   |       |--EXPR -> EXPR [307:22]
    |       |   |               |   |       |   `--ASSIGN -> = [307:22]
    |       |   |               |   |       |       |--IDENT -> x [307:20]
    |       |   |               |   |       |       `--NUM_INT -> 1 [307:24]
    |       |   |               |   |       |--SEMI -> ; [307:25]
    |       |   |               |   |       |--LITERAL_YIELD -> yield [308:20]
    |       |   |               |   |       |   |--EXPR -> EXPR [308:26]
    |       |   |               |   |       |   |   `--LITERAL_TRUE -> true [308:26]
    |       |   |               |   |       |   `--SEMI -> ; [308:30]
    |       |   |               |   |       `--RCURLY -> } [309:16]
    |       |   |               |   `--RCURLY -> } [310:12]
    |       |   |               |--RPAREN -> ) [310:13]
    |       |   |               `--EQUAL -> == [310:20]
    |       |   |                   |--IDENT -> x [310:18]
    |       |   |                   `--NUM_INT -> 1 [310:23]
    |       |   |--SEMI -> ; [310:24]
    |       |   |--LITERAL_IF -> if [312:12]
    |       |   |   |--LPAREN -> ( [312:15]
    |       |   |   |--EXPR -> EXPR [312:16]
    |       |   |   |   `--LNOT -> ! [312:16]
    |       |   |   |       `--IDENT -> tA [312:17]
    |       |   |   |--RPAREN -> ) [312:19]
    |       |   |   `--SLIST -> { [312:21]
    |       |   |       |--LITERAL_THROW -> throw [313:16]
    |       |   |       |   |--EXPR -> EXPR [313:22]
    |       |   |       |   |   `--LITERAL_NEW -> new [313:22]
    |       |   |       |   |       |--IDENT -> IllegalStateException [313:26]
    |       |   |       |   |       |--LPAREN -> ( [313:47]
    |       |   |       |   |       |--ELIST -> ELIST [313:48]
    |       |   |       |   |       |   `--EXPR -> EXPR [313:48]
    |       |   |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [313:48]
    |       |   |       |   |       `--RPAREN -> ) [313:68]
    |       |   |       |   `--SEMI -> ; [313:69]
    |       |   |       `--RCURLY -> } [314:12]
    |       |   `--RCURLY -> } [315:8]
    |       `--RCURLY -> } [316:4]
    |--STATIC_INIT -> STATIC_INIT [317:4]
    |   `--SLIST -> { [317:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [318:8]
    |       |   |--MODIFIERS -> MODIFIERS [318:8]
    |       |   |   `--FINAL -> final [318:8]
    |       |   |--TYPE -> TYPE [318:14]
    |       |   |   `--LITERAL_INT -> int [318:14]
    |       |   `--IDENT -> x [318:18]
    |       |--SEMI -> ; [318:19]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [319:8]
    |       |   |--MODIFIERS -> MODIFIERS [319:8]
    |       |   |--TYPE -> TYPE [319:8]
    |       |   |   `--IDENT -> T [319:8]
    |       |   |--IDENT -> e [319:10]
    |       |   `--ASSIGN -> = [319:12]
    |       |       `--EXPR -> EXPR [319:15]
    |       |           `--DOT -> . [319:15]
    |       |               |--IDENT -> T [319:14]
    |       |               `--IDENT -> C [319:16]
    |       |--SEMI -> ; [319:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [321:8]
    |       |   |--MODIFIERS -> MODIFIERS [321:8]
    |       |   |--TYPE -> TYPE [321:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [321:8]
    |       |   |--IDENT -> tA [321:16]
    |       |   `--ASSIGN -> = [321:19]
    |       |       `--EXPR -> EXPR [325:11]
    |       |           `--LOR -> || [325:11]
    |       |               |--LPAREN -> ( [321:21]
    |       |               |--LITERAL_SWITCH -> switch [321:22]
    |       |               |   |--LPAREN -> ( [321:28]
    |       |               |   |--EXPR -> EXPR [321:29]
    |       |               |   |   `--IDENT -> e [321:29]
    |       |               |   |--RPAREN -> ) [321:30]
    |       |               |   |--LCURLY -> { [321:32]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [322:12]
    |       |               |   |   |--LITERAL_CASE -> case [322:12]
    |       |               |   |   |   |--EXPR -> EXPR [322:17]
    |       |               |   |   |   |   `--IDENT -> A [322:17]
    |       |               |   |   |   `--COLON -> : [322:18]
    |       |               |   |   `--SLIST -> SLIST [322:22]
    |       |               |   |       |--EXPR -> EXPR [322:22]
    |       |               |   |       |   `--ASSIGN -> = [322:22]
    |       |               |   |       |       |--IDENT -> x [322:20]
    |       |               |   |       |       `--NUM_INT -> 1 [322:24]
    |       |               |   |       |--SEMI -> ; [322:25]
    |       |               |   |       `--LITERAL_YIELD -> yield [322:27]
    |       |               |   |           |--EXPR -> EXPR [322:33]
    |       |               |   |           |   `--LITERAL_TRUE -> true [322:33]
    |       |               |   |           `--SEMI -> ; [322:37]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [323:12]
    |       |               |   |   |--LITERAL_CASE -> case [323:12]
    |       |               |   |   |   |--EXPR -> EXPR [323:17]
    |       |               |   |   |   |   `--IDENT -> B [323:17]
    |       |               |   |   |   `--COLON -> : [323:18]
    |       |               |   |   `--SLIST -> SLIST [323:20]
    |       |               |   |       `--LITERAL_YIELD -> yield [323:20]
    |       |               |   |           |--EXPR -> EXPR [323:39]
    |       |               |   |           |   `--LOR -> || [323:39]
    |       |               |   |           |       |--EQUAL -> == [323:34]
    |       |               |   |           |       |   |--LPAREN -> ( [323:26]
    |       |               |   |           |       |   |--ASSIGN -> = [323:29]
    |       |               |   |           |       |   |   |--IDENT -> x [323:27]
    |       |               |   |           |       |   |   `--NUM_INT -> 2 [323:31]
    |       |               |   |           |       |   |--RPAREN -> ) [323:32]
    |       |               |   |           |       |   `--NUM_INT -> 2 [323:37]
    |       |               |   |           |       `--LITERAL_TRUE -> true [323:42]
    |       |               |   |           `--SEMI -> ; [323:46]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [324:12]
    |       |               |   |   |--LITERAL_DEFAULT -> default [324:12]
    |       |               |   |   |   `--COLON -> : [324:19]
    |       |               |   |   `--SLIST -> SLIST [324:21]
    |       |               |   |       `--LITERAL_YIELD -> yield [324:21]
    |       |               |   |           |--EXPR -> EXPR [324:27]
    |       |               |   |           |   `--LITERAL_FALSE -> false [324:27]
    |       |               |   |           `--SEMI -> ; [324:32]
    |       |               |   `--RCURLY -> } [325:8]
    |       |               |--RPAREN -> ) [325:9]
    |       |               `--EQUAL -> == [325:22]
    |       |                   |--LPAREN -> ( [325:14]
    |       |                   |--ASSIGN -> = [325:17]
    |       |                   |   |--IDENT -> x [325:15]
    |       |                   |   `--NUM_INT -> 3 [325:19]
    |       |                   |--RPAREN -> ) [325:20]
    |       |                   `--NUM_INT -> 3 [325:25]
    |       |--SEMI -> ; [325:26]
    |       |--LITERAL_IF -> if [327:8]
    |       |   |--LPAREN -> ( [327:11]
    |       |   |--EXPR -> EXPR [327:14]
    |       |   |   `--NOT_EQUAL -> != [327:14]
    |       |   |       |--IDENT -> x [327:12]
    |       |   |       `--NUM_INT -> 3 [327:17]
    |       |   |--RPAREN -> ) [327:18]
    |       |   `--SLIST -> { [327:20]
    |       |       |--LITERAL_THROW -> throw [328:12]
    |       |       |   |--EXPR -> EXPR [328:18]
    |       |       |   |   `--LITERAL_NEW -> new [328:18]
    |       |       |   |       |--IDENT -> IllegalStateException [328:22]
    |       |       |   |       |--LPAREN -> ( [328:43]
    |       |       |   |       |--ELIST -> ELIST [328:44]
    |       |       |   |       |   `--EXPR -> EXPR [328:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [328:44]
    |       |       |   |       `--RPAREN -> ) [328:64]
    |       |       |   `--SEMI -> ; [328:65]
    |       |       `--RCURLY -> } [329:8]
    |       `--RCURLY -> } [330:4]
    |--STATIC_INIT -> STATIC_INIT [332:4]
    |   `--SLIST -> { [332:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [333:8]
    |       |   |--MODIFIERS -> MODIFIERS [333:8]
    |       |   |--TYPE -> TYPE [333:8]
    |       |   |   `--LITERAL_INT -> int [333:8]
    |       |   `--IDENT -> x [333:12]
    |       |--SEMI -> ; [333:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [334:8]
    |       |   |--MODIFIERS -> MODIFIERS [334:8]
    |       |   |--TYPE -> TYPE [334:8]
    |       |   |   `--IDENT -> T [334:8]
    |       |   |--IDENT -> e [334:10]
    |       |   `--ASSIGN -> = [334:12]
    |       |       `--EXPR -> EXPR [334:15]
    |       |           `--DOT -> . [334:15]
    |       |               |--IDENT -> T [334:14]
    |       |               `--IDENT -> A [334:16]
    |       |--SEMI -> ; [334:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [336:8]
    |       |   |--MODIFIERS -> MODIFIERS [336:8]
    |       |   |--TYPE -> TYPE [336:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [336:8]
    |       |   |--IDENT -> tA [336:16]
    |       |   `--ASSIGN -> = [336:19]
    |       |       `--EXPR -> EXPR [343:11]
    |       |           `--LAND -> && [343:11]
    |       |               |--LPAREN -> ( [336:21]
    |       |               |--LITERAL_SWITCH -> switch [336:22]
    |       |               |   |--LPAREN -> ( [336:29]
    |       |               |   |--EXPR -> EXPR [336:30]
    |       |               |   |   `--IDENT -> e [336:30]
    |       |               |   |--RPAREN -> ) [336:31]
    |       |               |   |--LCURLY -> { [336:33]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [337:12]
    |       |               |   |   |--LITERAL_CASE -> case [337:12]
    |       |               |   |   |   |--EXPR -> EXPR [337:17]
    |       |               |   |   |   |   `--IDENT -> A [337:17]
    |       |               |   |   |   `--COLON -> : [337:18]
    |       |               |   |   `--SLIST -> SLIST [338:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [338:16]
    |       |               |   |           |--EXPR -> EXPR [338:43]
    |       |               |   |           |   `--QUESTION -> ? [338:43]
    |       |               |   |           |       |--LAND -> && [338:31]
    |       |               |   |           |       |   |--METHOD_CALL -> ( [338:28]
    |       |               |   |           |       |   |   |--IDENT -> isTrue [338:22]
    |       |               |   |           |       |   |   |--ELIST -> ELIST [338:29]
    |       |               |   |           |       |   |   `--RPAREN -> ) [338:29]
    |       |               |   |           |       |   `--NOT_EQUAL -> != [338:36]
    |       |               |   |           |       |       |--IDENT -> e [338:34]
    |       |               |   |           |       |       `--DOT -> . [338:40]
    |       |               |   |           |       |           |--IDENT -> T [338:39]
    |       |               |   |           |       |           `--IDENT -> C [338:41]
    |       |               |   |           |       |--LAND -> && [338:58]
    |       |               |   |           |       |   |--EQUAL -> == [338:53]
    |       |               |   |           |       |   |   |--LPAREN -> ( [338:45]
    |       |               |   |           |       |   |   |--ASSIGN -> = [338:48]
    |       |               |   |           |       |   |   |   |--IDENT -> x [338:46]
    |       |               |   |           |       |   |   |   `--NUM_INT -> 1 [338:50]
    |       |               |   |           |       |   |   |--RPAREN -> ) [338:51]
    |       |               |   |           |       |   |   `--NUM_INT -> 1 [338:56]
    |       |               |   |           |       |   `--NOT_EQUAL -> != [338:63]
    |       |               |   |           |       |       |--IDENT -> e [338:61]
    |       |               |   |           |       |       `--DOT -> . [338:67]
    |       |               |   |           |       |           |--IDENT -> T [338:66]
    |       |               |   |           |       |           `--IDENT -> B [338:68]
    |       |               |   |           |       |--COLON -> : [338:70]
    |       |               |   |           |       `--LITERAL_FALSE -> false [338:72]
    |       |               |   |           `--SEMI -> ; [338:77]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [339:12]
    |       |               |   |   |--LITERAL_CASE -> case [339:12]
    |       |               |   |   |   |--EXPR -> EXPR [339:17]
    |       |               |   |   |   |   `--IDENT -> B [339:17]
    |       |               |   |   |   `--COLON -> : [339:18]
    |       |               |   |   `--SLIST -> SLIST [340:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [340:16]
    |       |               |   |           |--EXPR -> EXPR [340:35]
    |       |               |   |           |   `--LOR -> || [340:35]
    |       |               |   |           |       |--EQUAL -> == [340:30]
    |       |               |   |           |       |   |--LPAREN -> ( [340:22]
    |       |               |   |           |       |   |--ASSIGN -> = [340:25]
    |       |               |   |           |       |   |   |--IDENT -> x [340:23]
    |       |               |   |           |       |   |   `--NUM_INT -> 1 [340:27]
    |       |               |   |           |       |   |--RPAREN -> ) [340:28]
    |       |               |   |           |       |   `--NUM_INT -> 1 [340:33]
    |       |               |   |           |       `--METHOD_CALL -> ( [340:44]
    |       |               |   |           |           |--IDENT -> isTrue [340:38]
    |       |               |   |           |           |--ELIST -> ELIST [340:45]
    |       |               |   |           |           `--RPAREN -> ) [340:45]
    |       |               |   |           `--SEMI -> ; [340:46]
    |       |               |   |--CASE_GROUP -> CASE_GROUP [341:12]
    |       |               |   |   |--LITERAL_DEFAULT -> default [341:12]
    |       |               |   |   |   `--COLON -> : [341:19]
    |       |               |   |   `--SLIST -> SLIST [342:16]
    |       |               |   |       `--LITERAL_YIELD -> yield [342:16]
    |       |               |   |           |--EXPR -> EXPR [342:22]
    |       |               |   |           |   `--LITERAL_FALSE -> false [342:22]
    |       |               |   |           `--SEMI -> ; [342:27]
    |       |               |   `--RCURLY -> } [343:8]
    |       |               |--RPAREN -> ) [343:9]
    |       |               `--EQUAL -> == [343:16]
    |       |                   |--IDENT -> x [343:14]
    |       |                   `--NUM_INT -> 1 [343:19]
    |       |--SEMI -> ; [343:20]
    |       |--LITERAL_IF -> if [345:8]
    |       |   |--LPAREN -> ( [345:11]
    |       |   |--EXPR -> EXPR [345:12]
    |       |   |   `--LNOT -> ! [345:12]
    |       |   |       `--IDENT -> tA [345:13]
    |       |   |--RPAREN -> ) [345:15]
    |       |   `--SLIST -> { [345:17]
    |       |       |--LITERAL_THROW -> throw [346:12]
    |       |       |   |--EXPR -> EXPR [346:18]
    |       |       |   |   `--LITERAL_NEW -> new [346:18]
    |       |       |   |       |--IDENT -> IllegalStateException [346:22]
    |       |       |   |       |--LPAREN -> ( [346:43]
    |       |       |   |       |--ELIST -> ELIST [346:44]
    |       |       |   |       |   `--EXPR -> EXPR [346:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [346:44]
    |       |       |   |       `--RPAREN -> ) [346:64]
    |       |       |   `--SEMI -> ; [346:65]
    |       |       `--RCURLY -> } [347:8]
    |       `--RCURLY -> } [348:4]
    |--STATIC_INIT -> STATIC_INIT [350:4]
    |   `--SLIST -> { [350:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [351:8]
    |       |   |--MODIFIERS -> MODIFIERS [351:8]
    |       |   |--TYPE -> TYPE [351:8]
    |       |   |   `--LITERAL_INT -> int [351:8]
    |       |   `--IDENT -> x [351:12]
    |       |--SEMI -> ; [351:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [352:8]
    |       |   |--MODIFIERS -> MODIFIERS [352:8]
    |       |   |--TYPE -> TYPE [352:8]
    |       |   |   `--IDENT -> T [352:8]
    |       |   |--IDENT -> e [352:10]
    |       |   `--ASSIGN -> = [352:12]
    |       |       `--EXPR -> EXPR [352:15]
    |       |           `--DOT -> . [352:15]
    |       |               |--IDENT -> T [352:14]
    |       |               `--IDENT -> A [352:16]
    |       |--SEMI -> ; [352:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [354:8]
    |       |   |--MODIFIERS -> MODIFIERS [354:8]
    |       |   |--TYPE -> TYPE [354:8]
    |       |   |   `--LITERAL_INT -> int [354:8]
    |       |   |--IDENT -> v [354:12]
    |       |   `--ASSIGN -> = [354:14]
    |       |       `--EXPR -> EXPR [354:16]
    |       |           |--LPAREN -> ( [354:16]
    |       |           |--LITERAL_SWITCH -> switch [354:17]
    |       |           |   |--LPAREN -> ( [354:23]
    |       |           |   |--EXPR -> EXPR [354:24]
    |       |           |   |   `--IDENT -> e [354:24]
    |       |           |   |--RPAREN -> ) [354:25]
    |       |           |   |--LCURLY -> { [354:27]
    |       |           |   |--SWITCH_RULE -> SWITCH_RULE [355:12]
    |       |           |   |   |--LITERAL_CASE -> case [355:12]
    |       |           |   |   |   `--EXPR -> EXPR [355:17]
    |       |           |   |   |       `--IDENT -> A [355:17]
    |       |           |   |   |--LAMBDA -> -> [355:19]
    |       |           |   |   |--EXPR -> EXPR [355:24]
    |       |           |   |   |   `--ASSIGN -> = [355:24]
    |       |           |   |   |       |--IDENT -> x [355:22]
    |       |           |   |   |       `--NUM_INT -> 0 [355:26]
    |       |           |   |   `--SEMI -> ; [355:27]
    |       |           |   |--SWITCH_RULE -> SWITCH_RULE [356:12]
    |       |           |   |   |--LITERAL_CASE -> case [356:12]
    |       |           |   |   |   `--EXPR -> EXPR [356:17]
    |       |           |   |   |       `--IDENT -> B [356:17]
    |       |           |   |   |--LAMBDA -> -> [356:19]
    |       |           |   |   |--EXPR -> EXPR [356:24]
    |       |           |   |   |   `--ASSIGN -> = [356:24]
    |       |           |   |   |       |--IDENT -> x [356:22]
    |       |           |   |   |       `--NUM_INT -> 0 [356:26]
    |       |           |   |   `--SEMI -> ; [356:27]
    |       |           |   |--SWITCH_RULE -> SWITCH_RULE [357:12]
    |       |           |   |   |--LITERAL_CASE -> case [357:12]
    |       |           |   |   |   `--EXPR -> EXPR [357:17]
    |       |           |   |   |       `--IDENT -> C [357:17]
    |       |           |   |   |--LAMBDA -> -> [357:19]
    |       |           |   |   |--EXPR -> EXPR [357:24]
    |       |           |   |   |   `--ASSIGN -> = [357:24]
    |       |           |   |   |       |--IDENT -> x [357:22]
    |       |           |   |   |       `--NUM_INT -> 0 [357:26]
    |       |           |   |   `--SEMI -> ; [357:27]
    |       |           |   `--RCURLY -> } [358:8]
    |       |           `--RPAREN -> ) [358:9]
    |       |--SEMI -> ; [358:10]
    |       |--LITERAL_IF -> if [360:8]
    |       |   |--LPAREN -> ( [360:11]
    |       |   |--EXPR -> EXPR [360:19]
    |       |   |   `--LOR -> || [360:19]
    |       |   |       |--NOT_EQUAL -> != [360:14]
    |       |   |       |   |--IDENT -> x [360:12]
    |       |   |       |   `--NUM_INT -> 0 [360:17]
    |       |   |       `--NOT_EQUAL -> != [360:24]
    |       |   |           |--IDENT -> v [360:22]
    |       |   |           `--NUM_INT -> 0 [360:27]
    |       |   |--RPAREN -> ) [360:28]
    |       |   `--SLIST -> { [360:30]
    |       |       |--LITERAL_THROW -> throw [361:12]
    |       |       |   |--EXPR -> EXPR [361:18]
    |       |       |   |   `--LITERAL_NEW -> new [361:18]
    |       |       |   |       |--IDENT -> IllegalStateException [361:22]
    |       |       |   |       |--LPAREN -> ( [361:43]
    |       |       |   |       |--ELIST -> ELIST [361:44]
    |       |       |   |       |   `--EXPR -> EXPR [361:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [361:44]
    |       |       |   |       `--RPAREN -> ) [361:64]
    |       |       |   `--SEMI -> ; [361:65]
    |       |       `--RCURLY -> } [362:8]
    |       `--RCURLY -> } [363:4]
    |--INSTANCE_INIT -> INSTANCE_INIT [365:4]
    |   `--SLIST -> { [365:4]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [366:8]
    |       |   |--MODIFIERS -> MODIFIERS [366:8]
    |       |   |--TYPE -> TYPE [366:8]
    |       |   |   `--LITERAL_INT -> int [366:8]
    |       |   `--IDENT -> x [366:12]
    |       |--SEMI -> ; [366:13]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [367:8]
    |       |   |--MODIFIERS -> MODIFIERS [367:8]
    |       |   |--TYPE -> TYPE [367:8]
    |       |   |   `--IDENT -> T [367:8]
    |       |   |--IDENT -> e [367:10]
    |       |   `--ASSIGN -> = [367:12]
    |       |       `--EXPR -> EXPR [367:15]
    |       |           `--DOT -> . [367:15]
    |       |               |--IDENT -> T [367:14]
    |       |               `--IDENT -> A [367:16]
    |       |--SEMI -> ; [367:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [369:8]
    |       |   |--MODIFIERS -> MODIFIERS [369:8]
    |       |   |--TYPE -> TYPE [369:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [369:8]
    |       |   |--IDENT -> tA [369:16]
    |       |   `--ASSIGN -> = [369:19]
    |       |       `--EXPR -> EXPR [373:11]
    |       |           `--LAND -> && [373:11]
    |       |               |--LPAREN -> ( [369:21]
    |       |               |--LITERAL_SWITCH -> switch [369:22]
    |       |               |   |--LPAREN -> ( [369:28]
    |       |               |   |--EXPR -> EXPR [369:29]
    |       |               |   |   `--IDENT -> e [369:29]
    |       |               |   |--RPAREN -> ) [369:30]
    |       |               |   |--LCURLY -> { [369:32]
    |       |               |   |--SWITCH_RULE -> SWITCH_RULE [370:12]
    |       |               |   |   |--LITERAL_CASE -> case [370:12]
    |       |               |   |   |   `--EXPR -> EXPR [370:17]
    |       |               |   |   |       `--IDENT -> A [370:17]
    |       |               |   |   |--LAMBDA -> -> [370:19]
    |       |               |   |   `--SLIST -> { [370:22]
    |       |               |   |       |--EXPR -> EXPR [370:26]
    |       |               |   |       |   `--ASSIGN -> = [370:26]
    |       |               |   |       |       |--IDENT -> x [370:24]
    |       |               |   |       |       `--NUM_INT -> 1 [370:28]
    |       |               |   |       |--SEMI -> ; [370:29]
    |       |               |   |       |--LITERAL_YIELD -> yield [370:31]
    |       |               |   |       |   |--EXPR -> EXPR [370:37]
    |       |               |   |       |   |   `--LITERAL_TRUE -> true [370:37]
    |       |               |   |       |   `--SEMI -> ; [370:41]
    |       |               |   |       `--RCURLY -> } [370:43]
    |       |               |   |--SWITCH_RULE -> SWITCH_RULE [371:12]
    |       |               |   |   |--LITERAL_CASE -> case [371:12]
    |       |               |   |   |   `--EXPR -> EXPR [371:17]
    |       |               |   |   |       `--IDENT -> B [371:17]
    |       |               |   |   |--LAMBDA -> -> [371:19]
    |       |               |   |   `--SLIST -> { [371:22]
    |       |               |   |       |--EXPR -> EXPR [371:26]
    |       |               |   |       |   `--ASSIGN -> = [371:26]
    |       |               |   |       |       |--IDENT -> x [371:24]
    |       |               |   |       |       `--NUM_INT -> 1 [371:28]
    |       |               |   |       |--SEMI -> ; [371:29]
    |       |               |   |       |--LITERAL_YIELD -> yield [371:31]
    |       |               |   |       |   |--EXPR -> EXPR [371:37]
    |       |               |   |       |   |   `--LITERAL_TRUE -> true [371:37]
    |       |               |   |       |   `--SEMI -> ; [371:41]
    |       |               |   |       `--RCURLY -> } [371:43]
    |       |               |   |--SWITCH_RULE -> SWITCH_RULE [372:12]
    |       |               |   |   |--LITERAL_CASE -> case [372:12]
    |       |               |   |   |   `--EXPR -> EXPR [372:17]
    |       |               |   |   |       `--IDENT -> C [372:17]
    |       |               |   |   |--LAMBDA -> -> [372:19]
    |       |               |   |   `--SLIST -> { [372:22]
    |       |               |   |       |--EXPR -> EXPR [372:26]
    |       |               |   |       |   `--ASSIGN -> = [372:26]
    |       |               |   |       |       |--IDENT -> x [372:24]
    |       |               |   |       |       `--NUM_INT -> 1 [372:28]
    |       |               |   |       |--SEMI -> ; [372:29]
    |       |               |   |       |--LITERAL_YIELD -> yield [372:31]
    |       |               |   |       |   |--EXPR -> EXPR [372:37]
    |       |               |   |       |   |   `--LITERAL_TRUE -> true [372:37]
    |       |               |   |       |   `--SEMI -> ; [372:41]
    |       |               |   |       `--RCURLY -> } [372:43]
    |       |               |   `--RCURLY -> } [373:8]
    |       |               |--RPAREN -> ) [373:9]
    |       |               `--EQUAL -> == [373:16]
    |       |                   |--IDENT -> x [373:14]
    |       |                   `--NUM_INT -> 1 [373:19]
    |       |--SEMI -> ; [373:20]
    |       |--LITERAL_IF -> if [375:8]
    |       |   |--LPAREN -> ( [375:11]
    |       |   |--EXPR -> EXPR [375:12]
    |       |   |   `--LNOT -> ! [375:12]
    |       |   |       `--IDENT -> tA [375:13]
    |       |   |--RPAREN -> ) [375:15]
    |       |   `--SLIST -> { [375:17]
    |       |       |--LITERAL_THROW -> throw [376:12]
    |       |       |   |--EXPR -> EXPR [376:18]
    |       |       |   |   `--LITERAL_NEW -> new [376:18]
    |       |       |   |       |--IDENT -> IllegalStateException [376:22]
    |       |       |   |       |--LPAREN -> ( [376:43]
    |       |       |   |       |--ELIST -> ELIST [376:44]
    |       |       |   |       |   `--EXPR -> EXPR [376:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Unexpected result." [376:44]
    |       |       |   |       `--RPAREN -> ) [376:64]
    |       |       |   `--SEMI -> ; [376:65]
    |       |       `--RCURLY -> } [377:8]
    |       `--RCURLY -> } [378:4]
    |--RECORD_DEF -> RECORD_DEF [380:4]
    |   |--MODIFIERS -> MODIFIERS [380:4]
    |   |   `--LITERAL_PRIVATE -> private [380:4]
    |   |--LITERAL_RECORD -> record [380:12]
    |   |--IDENT -> DefiniteAssignment1 [380:19]
    |   |--LPAREN -> ( [380:38]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [380:39]
    |   |--RPAREN -> ) [380:39]
    |   `--OBJBLOCK -> OBJBLOCK [380:41]
    |       |--LCURLY -> { [380:41]
    |       |--METHOD_DEF -> METHOD_DEF [381:8]
    |       |   |--MODIFIERS -> MODIFIERS [381:8]
    |       |   |   `--LITERAL_STATIC -> static [381:8]
    |       |   |--TYPE -> TYPE [381:15]
    |       |   |   `--LITERAL_INT -> int [381:15]
    |       |   |--IDENT -> id [381:19]
    |       |   |--LPAREN -> ( [381:21]
    |       |   |--PARAMETERS -> PARAMETERS [381:22]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [381:22]
    |       |   |       |--MODIFIERS -> MODIFIERS [381:22]
    |       |   |       |--TYPE -> TYPE [381:22]
    |       |   |       |   `--LITERAL_INT -> int [381:22]
    |       |   |       `--IDENT -> id [381:26]
    |       |   |--RPAREN -> ) [381:28]
    |       |   `--SLIST -> { [381:29]
    |       |       |--LITERAL_RETURN -> return [381:30]
    |       |       |   |--EXPR -> EXPR [381:37]
    |       |       |   |   `--IDENT -> id [381:37]
    |       |       |   `--SEMI -> ; [381:39]
    |       |       `--RCURLY -> } [381:40]
    |       `--RCURLY -> } [382:4]
    |--METHOD_DEF -> METHOD_DEF [384:4]
    |   |--MODIFIERS -> MODIFIERS [384:4]
    |   |   `--LITERAL_PRIVATE -> private [384:4]
    |   |--TYPE -> TYPE [384:12]
    |   |   `--IDENT -> String [384:12]
    |   |--IDENT -> print2 [384:19]
    |   |--LPAREN -> ( [384:25]
    |   |--PARAMETERS -> PARAMETERS [384:26]
    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [384:26]
    |   |   |   |--MODIFIERS -> MODIFIERS [384:26]
    |   |   |   |--TYPE -> TYPE [384:26]
    |   |   |   |   `--LITERAL_INT -> int [384:26]
    |   |   |   `--IDENT -> i [384:30]
    |   |   |--COMMA -> , [384:31]
    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [384:33]
    |   |   |   |--MODIFIERS -> MODIFIERS [384:33]
    |   |   |   |--TYPE -> TYPE [384:33]
    |   |   |   |   `--LITERAL_INT -> int [384:33]
    |   |   |   `--IDENT -> j [384:37]
    |   |   |--COMMA -> , [384:38]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [384:40]
    |   |       |--MODIFIERS -> MODIFIERS [384:40]
    |   |       |--TYPE -> TYPE [384:40]
    |   |       |   `--LITERAL_INT -> int [384:40]
    |   |       `--IDENT -> k [384:44]
    |   |--RPAREN -> ) [384:45]
    |   `--SLIST -> { [384:47]
    |       |--LITERAL_RETURN -> return [385:8]
    |       |   |--EXPR -> EXPR [385:15]
    |       |   |   `--LITERAL_SWITCH -> switch [385:15]
    |       |   |       |--LPAREN -> ( [385:22]
    |       |   |       |--EXPR -> EXPR [385:23]
    |       |   |       |   `--IDENT -> i [385:23]
    |       |   |       |--RPAREN -> ) [385:24]
    |       |   |       |--LCURLY -> { [385:26]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [386:12]
    |       |   |       |   |--LITERAL_CASE -> case [386:12]
    |       |   |       |   |   |--EXPR -> EXPR [386:17]
    |       |   |       |   |   |   `--NUM_INT -> 0 [386:17]
    |       |   |       |   |   `--COLON -> : [386:18]
    |       |   |       |   `--SLIST -> SLIST [387:16]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [387:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [387:16]
    |       |   |       |       |   |--TYPE -> TYPE [387:16]
    |       |   |       |       |   |   `--IDENT -> String [387:16]
    |       |   |       |       |   `--IDENT -> r [387:23]
    |       |   |       |       |--SEMI -> ; [387:24]
    |       |   |       |       |--LABELED_STAT -> : [388:21]
    |       |   |       |       |   |--IDENT -> OUTER [388:16]
    |       |   |       |       |   `--LITERAL_SWITCH -> switch [388:23]
    |       |   |       |       |       |--LPAREN -> ( [388:30]
    |       |   |       |       |       |--EXPR -> EXPR [388:31]
    |       |   |       |       |       |   `--IDENT -> j [388:31]
    |       |   |       |       |       |--RPAREN -> ) [388:32]
    |       |   |       |       |       |--LCURLY -> { [388:34]
    |       |   |       |       |       |--CASE_GROUP -> CASE_GROUP [389:20]
    |       |   |       |       |       |   |--LITERAL_CASE -> case [389:20]
    |       |   |       |       |       |   |   |--EXPR -> EXPR [389:25]
    |       |   |       |       |       |   |   |   `--NUM_INT -> 0 [389:25]
    |       |   |       |       |       |   |   `--COLON -> : [389:26]
    |       |   |       |       |       |   `--SLIST -> SLIST [390:24]
    |       |   |       |       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [390:24]
    |       |   |       |       |       |       |   |--MODIFIERS -> MODIFIERS [390:24]
    |       |   |       |       |       |       |   |--TYPE -> TYPE [390:24]
    |       |   |       |       |       |       |   |   `--IDENT -> String [390:24]
    |       |   |       |       |       |       |   `--IDENT -> res [390:31]
    |       |   |       |       |       |       |--SEMI -> ; [390:34]
    |       |   |       |       |       |       |--LABELED_STAT -> : [391:29]
    |       |   |       |       |       |       |   |--IDENT -> INNER [391:24]
    |       |   |       |       |       |       |   `--LITERAL_SWITCH -> switch [391:31]
    |       |   |       |       |       |       |       |--LPAREN -> ( [391:38]
    |       |   |       |       |       |       |       |--EXPR -> EXPR [391:39]
    |       |   |       |       |       |       |       |   `--IDENT -> k [391:39]
    |       |   |       |       |       |       |       |--RPAREN -> ) [391:40]
    |       |   |       |       |       |       |       |--LCURLY -> { [391:42]
    |       |   |       |       |       |       |       |--CASE_GROUP -> CASE_GROUP [392:28]
    |       |   |       |       |       |       |       |   |--LITERAL_CASE -> case [392:28]
    |       |   |       |       |       |       |       |   |   |--EXPR -> EXPR [392:33]
    |       |   |       |       |       |       |       |   |   |   `--NUM_INT -> 0 [392:33]
    |       |   |       |       |       |       |       |   |   `--COLON -> : [392:34]
    |       |   |       |       |       |       |       |   `--SLIST -> SLIST [392:40]
    |       |   |       |       |       |       |       |       |--EXPR -> EXPR [392:40]
    |       |   |       |       |       |       |       |       |   `--ASSIGN -> = [392:40]
    |       |   |       |       |       |       |       |       |       |--IDENT -> res [392:36]
    |       |   |       |       |       |       |       |       |       `--STRING_LITERAL -> "0-0-0" [392:42]
    |       |   |       |       |       |       |       |       |--SEMI -> ; [392:49]
    |       |   |       |       |       |       |       |       `--LITERAL_BREAK -> break [392:51]
    |       |   |       |       |       |       |       |           `--SEMI -> ; [392:56]
    |       |   |       |       |       |       |       |--CASE_GROUP -> CASE_GROUP [393:28]
    |       |   |       |       |       |       |       |   |--LITERAL_CASE -> case [393:28]
    |       |   |       |       |       |       |       |   |   |--EXPR -> EXPR [393:33]
    |       |   |       |       |       |       |       |   |   |   `--NUM_INT -> 1 [393:33]
    |       |   |       |       |       |       |       |   |   `--COLON -> : [393:34]
    |       |   |       |       |       |       |       |   `--SLIST -> SLIST [393:40]
    |       |   |       |       |       |       |       |       |--EXPR -> EXPR [393:40]
    |       |   |       |       |       |       |       |       |   `--ASSIGN -> = [393:40]
    |       |   |       |       |       |       |       |       |       |--IDENT -> res [393:36]
    |       |   |       |       |       |       |       |       |       `--STRING_LITERAL -> "0-0-1" [393:42]
    |       |   |       |       |       |       |       |       |--SEMI -> ; [393:49]
    |       |   |       |       |       |       |       |       `--LITERAL_BREAK -> break [393:51]
    |       |   |       |       |       |       |       |           `--SEMI -> ; [393:56]
    |       |   |       |       |       |       |       |--CASE_GROUP -> CASE_GROUP [394:28]
    |       |   |       |       |       |       |       |   |--LITERAL_CASE -> case [394:28]
    |       |   |       |       |       |       |       |   |   |--EXPR -> EXPR [394:33]
    |       |   |       |       |       |       |       |   |   |   `--NUM_INT -> 2 [394:33]
    |       |   |       |       |       |       |       |   |   `--COLON -> : [394:34]
    |       |   |       |       |       |       |       |   `--SLIST -> SLIST [394:40]
    |       |   |       |       |       |       |       |       |--EXPR -> EXPR [394:40]
    |       |   |       |       |       |       |       |       |   `--ASSIGN -> = [394:40]
    |       |   |       |       |       |       |       |       |       |--IDENT -> res [394:36]
    |       |   |       |       |       |       |       |       |       `--STRING_LITERAL -> "0-0-2" [394:42]
    |       |   |       |       |       |       |       |       |--SEMI -> ; [394:49]
    |       |   |       |       |       |       |       |       `--LITERAL_BREAK -> break [394:51]
    |       |   |       |       |       |       |       |           |--IDENT -> INNER [394:57]
    |       |   |       |       |       |       |       |           `--SEMI -> ; [394:62]
    |       |   |       |       |       |       |       |--CASE_GROUP -> CASE_GROUP [395:28]
    |       |   |       |       |       |       |       |   |--LITERAL_DEFAULT -> default [395:28]
    |       |   |       |       |       |       |       |   |   `--COLON -> : [395:35]
    |       |   |       |       |       |       |       |   `--SLIST -> SLIST [395:39]
    |       |   |       |       |       |       |       |       |--EXPR -> EXPR [395:39]
    |       |   |       |       |       |       |       |       |   `--ASSIGN -> = [395:39]
    |       |   |       |       |       |       |       |       |       |--IDENT -> r [395:37]
    |       |   |       |       |       |       |       |       |       `--STRING_LITERAL -> "0-0-X" [395:41]
    |       |   |       |       |       |       |       |       |--SEMI -> ; [395:48]
    |       |   |       |       |       |       |       |       `--LITERAL_BREAK -> break [395:50]
    |       |   |       |       |       |       |       |           |--IDENT -> OUTER [395:56]
    |       |   |       |       |       |       |       |           `--SEMI -> ; [395:61]
    |       |   |       |       |       |       |       `--RCURLY -> } [396:24]
    |       |   |       |       |       |       |--EXPR -> EXPR [397:26]
    |       |   |       |       |       |       |   `--ASSIGN -> = [397:26]
    |       |   |       |       |       |       |       |--IDENT -> r [397:24]
    |       |   |       |       |       |       |       `--IDENT -> res [397:28]
    |       |   |       |       |       |       |--SEMI -> ; [397:31]
    |       |   |       |       |       |       `--LITERAL_BREAK -> break [398:24]
    |       |   |       |       |       |           `--SEMI -> ; [398:29]
    |       |   |       |       |       |--CASE_GROUP -> CASE_GROUP [399:20]
    |       |   |       |       |       |   |--LITERAL_CASE -> case [399:20]
    |       |   |       |       |       |   |   |--EXPR -> EXPR [399:25]
    |       |   |       |       |       |   |   |   `--NUM_INT -> 1 [399:25]
    |       |   |       |       |       |   |   `--COLON -> : [399:26]
    |       |   |       |       |       |   `--SLIST -> SLIST [400:26]
    |       |   |       |       |       |       |--EXPR -> EXPR [400:26]
    |       |   |       |       |       |       |   `--ASSIGN -> = [400:26]
    |       |   |       |       |       |       |       |--IDENT -> r [400:24]
    |       |   |       |       |       |       |       `--STRING_LITERAL -> "0-1" [400:28]
    |       |   |       |       |       |       |--SEMI -> ; [400:33]
    |       |   |       |       |       |       `--LITERAL_BREAK -> break [401:24]
    |       |   |       |       |       |           `--SEMI -> ; [401:29]
    |       |   |       |       |       |--CASE_GROUP -> CASE_GROUP [402:20]
    |       |   |       |       |       |   |--LITERAL_DEFAULT -> default [402:20]
    |       |   |       |       |       |   |   `--COLON -> : [402:27]
    |       |   |       |       |       |   `--SLIST -> SLIST [403:26]
    |       |   |       |       |       |       |--EXPR -> EXPR [403:26]
    |       |   |       |       |       |       |   `--ASSIGN -> = [403:26]
    |       |   |       |       |       |       |       |--IDENT -> r [403:24]
    |       |   |       |       |       |       |       `--STRING_LITERAL -> "0-X" [403:28]
    |       |   |       |       |       |       |--SEMI -> ; [403:33]
    |       |   |       |       |       |       `--LITERAL_BREAK -> break [404:24]
    |       |   |       |       |       |           `--SEMI -> ; [404:29]
    |       |   |       |       |       `--RCURLY -> } [405:16]
    |       |   |       |       `--LITERAL_YIELD -> yield [406:16]
    |       |   |       |           |--EXPR -> EXPR [406:22]
    |       |   |       |           |   `--IDENT -> r [406:22]
    |       |   |       |           `--SEMI -> ; [406:23]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [407:12]
    |       |   |       |   |--LITERAL_CASE -> case [407:12]
    |       |   |       |   |   |--EXPR -> EXPR [407:17]
    |       |   |       |   |   |   `--NUM_INT -> 1 [407:17]
    |       |   |       |   |   `--COLON -> : [407:18]
    |       |   |       |   `--SLIST -> SLIST [408:16]
    |       |   |       |       `--LITERAL_YIELD -> yield [408:16]
    |       |   |       |           |--EXPR -> EXPR [408:22]
    |       |   |       |           |   `--STRING_LITERAL -> "1" [408:22]
    |       |   |       |           `--SEMI -> ; [408:25]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [409:12]
    |       |   |       |   |--LITERAL_CASE -> case [409:12]
    |       |   |       |   |   |--EXPR -> EXPR [409:17]
    |       |   |       |   |   |   `--NUM_INT -> 2 [409:17]
    |       |   |       |   |   `--COLON -> : [409:18]
    |       |   |       |   `--SLIST -> SLIST [410:19]
    |       |   |       |       |--LABELED_STAT -> : [410:19]
    |       |   |       |       |   |--IDENT -> LOP [410:16]
    |       |   |       |       |   `--LITERAL_WHILE -> while [410:21]
    |       |   |       |       |       |--LPAREN -> ( [410:27]
    |       |   |       |       |       |--EXPR -> EXPR [410:32]
    |       |   |       |       |       |   `--GT -> > [410:32]
    |       |   |       |       |       |       |--POST_DEC -> -- [410:29]
    |       |   |       |       |       |       |   `--IDENT -> j [410:28]
    |       |   |       |       |       |       `--NUM_INT -> 0 [410:34]
    |       |   |       |       |       |--RPAREN -> ) [410:35]
    |       |   |       |       |       `--SLIST -> { [410:37]
    |       |   |       |       |           |--LITERAL_IF -> if [411:20]
    |       |   |       |       |           |   |--LPAREN -> ( [411:23]
    |       |   |       |       |           |   |--EXPR -> EXPR [411:26]
    |       |   |       |       |           |   |   `--EQUAL -> == [411:26]
    |       |   |       |       |           |   |       |--IDENT -> k [411:24]
    |       |   |       |       |           |   |       `--NUM_INT -> 5 [411:29]
    |       |   |       |       |           |   |--RPAREN -> ) [411:30]
    |       |   |       |       |           |   `--SLIST -> { [411:32]
    |       |   |       |       |           |       |--EXPR -> EXPR [412:25]
    |       |   |       |       |           |       |   `--POST_DEC -> -- [412:25]
    |       |   |       |       |           |       |       `--IDENT -> k [412:24]
    |       |   |       |       |           |       |--SEMI -> ; [412:27]
    |       |   |       |       |           |       |--LITERAL_CONTINUE -> continue [413:24]
    |       |   |       |       |           |       |   `--SEMI -> ; [413:32]
    |       |   |       |       |           |       `--RCURLY -> } [414:20]
    |       |   |       |       |           |--LITERAL_BREAK -> break [415:20]
    |       |   |       |       |           |   |--IDENT -> LOP [415:26]
    |       |   |       |       |           |   `--SEMI -> ; [415:29]
    |       |   |       |       |           `--RCURLY -> } [416:16]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [417:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [417:16]
    |       |   |       |       |   |--TYPE -> TYPE [417:16]
    |       |   |       |       |   |   |--IDENT -> Supplier [417:16]
    |       |   |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [417:24]
    |       |   |       |       |   |       |--GENERIC_START -> < [417:24]
    |       |   |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [417:25]
    |       |   |       |       |   |       |   `--IDENT -> String [417:25]
    |       |   |       |       |   |       `--GENERIC_END -> > [417:31]
    |       |   |       |       |   |--IDENT -> getter [417:33]
    |       |   |       |       |   `--ASSIGN -> = [417:40]
    |       |   |       |       |       `--LAMBDA -> -> [417:45]
    |       |   |       |       |           |--LPAREN -> ( [417:42]
    |       |   |       |       |           |--PARAMETERS -> PARAMETERS [417:43]
    |       |   |       |       |           |--RPAREN -> ) [417:43]
    |       |   |       |       |           `--SLIST -> { [417:48]
    |       |   |       |       |               |--LITERAL_RETURN -> return [417:50]
    |       |   |       |       |               |   |--EXPR -> EXPR [417:57]
    |       |   |       |       |               |   |   `--STRING_LITERAL -> "2-X-5" [417:57]
    |       |   |       |       |               |   `--SEMI -> ; [417:64]
    |       |   |       |       |               `--RCURLY -> } [417:66]
    |       |   |       |       |--SEMI -> ; [417:67]
    |       |   |       |       `--LITERAL_YIELD -> yield [418:16]
    |       |   |       |           |--EXPR -> EXPR [418:32]
    |       |   |       |           |   `--METHOD_CALL -> ( [418:32]
    |       |   |       |           |       |--DOT -> . [418:28]
    |       |   |       |           |       |   |--IDENT -> getter [418:22]
    |       |   |       |           |       |   `--IDENT -> get [418:29]
    |       |   |       |           |       |--ELIST -> ELIST [418:33]
    |       |   |       |           |       `--RPAREN -> ) [418:33]
    |       |   |       |           `--SEMI -> ; [418:34]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [419:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [419:12]
    |       |   |       |   |   `--COLON -> : [419:19]
    |       |   |       |   `--SLIST -> SLIST [420:16]
    |       |   |       |       `--LITERAL_YIELD -> yield [420:16]
    |       |   |       |           |--EXPR -> EXPR [420:22]
    |       |   |       |           |   `--STRING_LITERAL -> "X" [420:22]
    |       |   |       |           `--SEMI -> ; [420:25]
    |       |   |       `--RCURLY -> } [421:8]
    |       |   `--SEMI -> ; [421:9]
    |       `--RCURLY -> } [422:4]
    |--METHOD_DEF -> METHOD_DEF [424:4]
    |   |--MODIFIERS -> MODIFIERS [424:4]
    |   |   `--LITERAL_PRIVATE -> private [424:4]
    |   |--TYPE -> TYPE [424:12]
    |   |   `--IDENT -> String [424:12]
    |   |--IDENT -> expression1 [424:19]
    |   |--LPAREN -> ( [424:30]
    |   |--PARAMETERS -> PARAMETERS [424:31]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [424:31]
    |   |       |--MODIFIERS -> MODIFIERS [424:31]
    |   |       |--TYPE -> TYPE [424:31]
    |   |       |   `--IDENT -> T [424:31]
    |   |       `--IDENT -> t [424:33]
    |   |--RPAREN -> ) [424:34]
    |   `--SLIST -> { [424:36]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [425:8]
    |       |   |--MODIFIERS -> MODIFIERS [425:8]
    |       |   |--TYPE -> TYPE [425:8]
    |       |   |   `--IDENT -> String [425:8]
    |       |   |--IDENT -> help [425:15]
    |       |   `--ASSIGN -> = [425:20]
    |       |       `--EXPR -> EXPR [425:22]
    |       |           `--STRING_LITERAL -> "" [425:22]
    |       |--SEMI -> ; [425:24]
    |       |--LITERAL_RETURN -> return [426:8]
    |       |   |--EXPR -> EXPR [426:15]
    |       |   |   `--LITERAL_SWITCH -> switch [426:15]
    |       |   |       |--LPAREN -> ( [426:22]
    |       |   |       |--EXPR -> EXPR [426:23]
    |       |   |       |   `--IDENT -> t [426:23]
    |       |   |       |--RPAREN -> ) [426:24]
    |       |   |       |--LCURLY -> { [426:26]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [427:12]
    |       |   |       |   |--LITERAL_CASE -> case [427:12]
    |       |   |       |   |   |--EXPR -> EXPR [427:17]
    |       |   |       |   |   |   `--IDENT -> A [427:17]
    |       |   |       |   |   `--COLON -> : [427:18]
    |       |   |       |   `--SLIST -> SLIST [427:25]
    |       |   |       |       |--EXPR -> EXPR [427:25]
    |       |   |       |       |   `--ASSIGN -> = [427:25]
    |       |   |       |       |       |--IDENT -> help [427:20]
    |       |   |       |       |       `--STRING_LITERAL -> "a" [427:27]
    |       |   |       |       `--SEMI -> ; [427:30]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [428:12]
    |       |   |       |   |--LITERAL_CASE -> case [428:12]
    |       |   |       |   |   |--EXPR -> EXPR [428:17]
    |       |   |       |   |   |   `--IDENT -> B [428:17]
    |       |   |       |   |   `--COLON -> : [428:18]
    |       |   |       |   `--SLIST -> SLIST [428:25]
    |       |   |       |       |--EXPR -> EXPR [428:25]
    |       |   |       |       |   `--PLUS_ASSIGN -> += [428:25]
    |       |   |       |       |       |--IDENT -> help [428:20]
    |       |   |       |       |       `--STRING_LITERAL -> "b" [428:28]
    |       |   |       |       `--SEMI -> ; [428:31]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [429:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [429:12]
    |       |   |       |   |   `--COLON -> : [429:19]
    |       |   |       |   `--SLIST -> SLIST [429:21]
    |       |   |       |       `--LITERAL_YIELD -> yield [429:21]
    |       |   |       |           |--EXPR -> EXPR [429:27]
    |       |   |       |           |   `--IDENT -> help [429:27]
    |       |   |       |           `--SEMI -> ; [429:31]
    |       |   |       `--RCURLY -> } [430:8]
    |       |   `--SEMI -> ; [430:9]
    |       `--RCURLY -> } [431:4]
    |--METHOD_DEF -> METHOD_DEF [433:4]
    |   |--MODIFIERS -> MODIFIERS [433:4]
    |   |   `--LITERAL_PRIVATE -> private [433:4]
    |   |--TYPE -> TYPE [433:12]
    |   |   `--IDENT -> String [433:12]
    |   |--IDENT -> expression2 [433:19]
    |   |--LPAREN -> ( [433:30]
    |   |--PARAMETERS -> PARAMETERS [433:31]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [433:31]
    |   |       |--MODIFIERS -> MODIFIERS [433:31]
    |   |       |--TYPE -> TYPE [433:31]
    |   |       |   `--IDENT -> T [433:31]
    |   |       `--IDENT -> t [433:33]
    |   |--RPAREN -> ) [433:34]
    |   `--SLIST -> { [433:36]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [434:8]
    |       |   |--MODIFIERS -> MODIFIERS [434:8]
    |       |   |--TYPE -> TYPE [434:8]
    |       |   |   `--IDENT -> String [434:8]
    |       |   |--IDENT -> help [434:15]
    |       |   `--ASSIGN -> = [434:20]
    |       |       `--EXPR -> EXPR [434:22]
    |       |           `--STRING_LITERAL -> "" [434:22]
    |       |--SEMI -> ; [434:24]
    |       |--LITERAL_RETURN -> return [435:8]
    |       |   |--EXPR -> EXPR [435:15]
    |       |   |   `--LITERAL_SWITCH -> switch [435:15]
    |       |   |       |--LPAREN -> ( [435:22]
    |       |   |       |--EXPR -> EXPR [435:23]
    |       |   |       |   `--IDENT -> t [435:23]
    |       |   |       |--RPAREN -> ) [435:24]
    |       |   |       |--LCURLY -> { [435:26]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [436:12]
    |       |   |       |   |--LITERAL_CASE -> case [436:12]
    |       |   |       |   |   |--EXPR -> EXPR [436:17]
    |       |   |       |   |   |   `--IDENT -> A [436:17]
    |       |   |       |   |   `--COLON -> : [436:18]
    |       |   |       |   `--SLIST -> SLIST [436:25]
    |       |   |       |       |--EXPR -> EXPR [436:25]
    |       |   |       |       |   `--ASSIGN -> = [436:25]
    |       |   |       |       |       |--IDENT -> help [436:20]
    |       |   |       |       |       `--STRING_LITERAL -> "a" [436:27]
    |       |   |       |       `--SEMI -> ; [436:30]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [437:12]
    |       |   |       |   |--LITERAL_CASE -> case [437:12]
    |       |   |       |   |   |--EXPR -> EXPR [437:17]
    |       |   |       |   |   |   `--IDENT -> B [437:17]
    |       |   |       |   |   `--COLON -> : [437:18]
    |       |   |       |   `--SLIST -> SLIST [437:25]
    |       |   |       |       |--EXPR -> EXPR [437:25]
    |       |   |       |       |   `--PLUS_ASSIGN -> += [437:25]
    |       |   |       |       |       |--IDENT -> help [437:20]
    |       |   |       |       |       `--STRING_LITERAL -> "b" [437:28]
    |       |   |       |       `--SEMI -> ; [437:31]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [438:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [438:12]
    |       |   |       |   |   `--COLON -> : [438:19]
    |       |   |       |   `--SLIST -> SLIST [438:21]
    |       |   |       |       `--LITERAL_YIELD -> yield [438:21]
    |       |   |       |           |--EXPR -> EXPR [438:27]
    |       |   |       |           |   `--IDENT -> help [438:27]
    |       |   |       |           `--SEMI -> ; [438:31]
    |       |   |       `--RCURLY -> } [439:8]
    |       |   `--SEMI -> ; [439:9]
    |       `--RCURLY -> } [440:4]
    |--METHOD_DEF -> METHOD_DEF [442:4]
    |   |--MODIFIERS -> MODIFIERS [442:4]
    |   |--TYPE -> TYPE [442:4]
    |   |   |--IDENT -> I [442:4]
    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [442:5]
    |   |       |--GENERIC_START -> < [442:5]
    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [442:6]
    |   |       |   `--IDENT -> String [442:6]
    |   |       `--GENERIC_END -> > [442:12]
    |   |--IDENT -> lambdaCapture1 [442:14]
    |   |--LPAREN -> ( [442:28]
    |   |--PARAMETERS -> PARAMETERS [442:29]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [442:29]
    |   |       |--MODIFIERS -> MODIFIERS [442:29]
    |   |       |--TYPE -> TYPE [442:29]
    |   |       |   `--LITERAL_INT -> int [442:29]
    |   |       `--IDENT -> i [442:33]
    |   |--RPAREN -> ) [442:34]
    |   `--SLIST -> { [442:36]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [443:8]
    |       |   |--MODIFIERS -> MODIFIERS [443:8]
    |       |   |--TYPE -> TYPE [443:8]
    |       |   |   `--LITERAL_INT -> int [443:8]
    |       |   |--IDENT -> j [443:12]
    |       |   `--ASSIGN -> = [443:14]
    |       |       `--EXPR -> EXPR [443:18]
    |       |           `--PLUS -> + [443:18]
    |       |               |--IDENT -> i [443:16]
    |       |               `--NUM_INT -> 1 [443:20]
    |       |--SEMI -> ; [443:21]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [444:8]
    |       |   |--MODIFIERS -> MODIFIERS [444:8]
    |       |   |--TYPE -> TYPE [444:8]
    |       |   |   |--IDENT -> I [444:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [444:9]
    |       |   |       |--GENERIC_START -> < [444:9]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [444:10]
    |       |   |       |   `--IDENT -> String [444:10]
    |       |   |       `--GENERIC_END -> > [444:16]
    |       |   |--IDENT -> r [444:18]
    |       |   `--ASSIGN -> = [444:20]
    |       |       `--EXPR -> EXPR [444:22]
    |       |           `--LITERAL_SWITCH -> switch [444:22]
    |       |               |--LPAREN -> ( [444:29]
    |       |               |--EXPR -> EXPR [444:30]
    |       |               |   `--IDENT -> i [444:30]
    |       |               |--RPAREN -> ) [444:31]
    |       |               |--LCURLY -> { [444:33]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [445:12]
    |       |               |   |--LITERAL_CASE -> case [445:12]
    |       |               |   |   `--EXPR -> EXPR [445:17]
    |       |               |   |       `--NUM_INT -> 0 [445:17]
    |       |               |   |--LAMBDA -> -> [445:19]
    |       |               |   |--LAMBDA -> -> [445:25]
    |       |               |   |   |--LPAREN -> ( [445:22]
    |       |               |   |   |--PARAMETERS -> PARAMETERS [445:23]
    |       |               |   |   |--RPAREN -> ) [445:23]
    |       |               |   |   `--EXPR -> EXPR [445:32]
    |       |               |   |       `--PLUS -> + [445:32]
    |       |               |   |           |--STRING_LITERAL -> "0" [445:28]
    |       |               |   |           `--IDENT -> i [445:34]
    |       |               |   `--SEMI -> ; [445:35]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [446:12]
    |       |               |   |--LITERAL_CASE -> case [446:12]
    |       |               |   |   `--EXPR -> EXPR [446:17]
    |       |               |   |       `--NUM_INT -> 1 [446:17]
    |       |               |   |--LAMBDA -> -> [446:19]
    |       |               |   |--LAMBDA -> -> [446:25]
    |       |               |   |   |--LPAREN -> ( [446:22]
    |       |               |   |   |--PARAMETERS -> PARAMETERS [446:23]
    |       |               |   |   |--RPAREN -> ) [446:23]
    |       |               |   |   `--EXPR -> EXPR [446:32]
    |       |               |   |       `--PLUS -> + [446:32]
    |       |               |   |           |--STRING_LITERAL -> "1" [446:28]
    |       |               |   |           `--IDENT -> j [446:34]
    |       |               |   `--SEMI -> ; [446:35]
    |       |               |--SWITCH_RULE -> SWITCH_RULE [447:12]
    |       |               |   |--LITERAL_DEFAULT -> default [447:12]
    |       |               |   |--LAMBDA -> -> [447:20]
    |       |               |   `--SLIST -> { [447:23]
    |       |               |       |--VARIABLE_DEF -> VARIABLE_DEF [448:16]
    |       |               |       |   |--MODIFIERS -> MODIFIERS [448:16]
    |       |               |       |   |--TYPE -> TYPE [448:16]
    |       |               |       |   |   `--IDENT -> String [448:16]
    |       |               |       |   |--IDENT -> k [448:23]
    |       |               |       |   `--ASSIGN -> = [448:25]
    |       |               |       |       `--EXPR -> EXPR [448:27]
    |       |               |       |           `--STRING_LITERAL -> "D" [448:27]
    |       |               |       |--SEMI -> ; [448:30]
    |       |               |       |--LITERAL_YIELD -> yield [449:16]
    |       |               |       |   |--LAMBDA -> -> [449:25]
    |       |               |       |   |   |--LPAREN -> ( [449:22]
    |       |               |       |   |   |--PARAMETERS -> PARAMETERS [449:23]
    |       |               |       |   |   |--RPAREN -> ) [449:23]
    |       |               |       |   |   `--EXPR -> EXPR [449:28]
    |       |               |       |   |       `--IDENT -> k [449:28]
    |       |               |       |   `--SEMI -> ; [449:29]
    |       |               |       `--RCURLY -> } [450:12]
    |       |               `--RCURLY -> } [451:8]
    |       |--SEMI -> ; [451:9]
    |       |--LITERAL_RETURN -> return [453:8]
    |       |   |--EXPR -> EXPR [453:15]
    |       |   |   `--IDENT -> r [453:15]
    |       |   `--SEMI -> ; [453:16]
    |       `--RCURLY -> } [454:4]
    |--METHOD_DEF -> METHOD_DEF [456:4]
    |   |--MODIFIERS -> MODIFIERS [456:4]
    |   |--TYPE -> TYPE [456:4]
    |   |   |--IDENT -> I [456:4]
    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [456:5]
    |   |       |--GENERIC_START -> < [456:5]
    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [456:6]
    |   |       |   `--IDENT -> String [456:6]
    |   |       `--GENERIC_END -> > [456:12]
    |   |--IDENT -> lambdaCapture2 [456:14]
    |   |--LPAREN -> ( [456:28]
    |   |--PARAMETERS -> PARAMETERS [456:29]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [456:29]
    |   |       |--MODIFIERS -> MODIFIERS [456:29]
    |   |       |--TYPE -> TYPE [456:29]
    |   |       |   `--LITERAL_INT -> int [456:29]
    |   |       `--IDENT -> i [456:33]
    |   |--RPAREN -> ) [456:34]
    |   `--SLIST -> { [456:36]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [457:8]
    |       |   |--MODIFIERS -> MODIFIERS [457:8]
    |       |   |--TYPE -> TYPE [457:8]
    |       |   |   `--LITERAL_INT -> int [457:8]
    |       |   |--IDENT -> j [457:12]
    |       |   `--ASSIGN -> = [457:14]
    |       |       `--EXPR -> EXPR [457:18]
    |       |           `--PLUS -> + [457:18]
    |       |               |--IDENT -> i [457:16]
    |       |               `--NUM_INT -> 1 [457:20]
    |       |--SEMI -> ; [457:21]
    |       |--LITERAL_RETURN -> return [459:8]
    |       |   |--EXPR -> EXPR [459:15]
    |       |   |   `--LITERAL_SWITCH -> switch [459:15]
    |       |   |       |--LPAREN -> ( [459:22]
    |       |   |       |--EXPR -> EXPR [459:23]
    |       |   |       |   `--IDENT -> i [459:23]
    |       |   |       |--RPAREN -> ) [459:24]
    |       |   |       |--LCURLY -> { [459:26]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [460:12]
    |       |   |       |   |--LITERAL_CASE -> case [460:12]
    |       |   |       |   |   `--EXPR -> EXPR [460:17]
    |       |   |       |   |       `--NUM_INT -> 0 [460:17]
    |       |   |       |   |--LAMBDA -> -> [460:19]
    |       |   |       |   |--LAMBDA -> -> [460:25]
    |       |   |       |   |   |--LPAREN -> ( [460:22]
    |       |   |       |   |   |--PARAMETERS -> PARAMETERS [460:23]
    |       |   |       |   |   |--RPAREN -> ) [460:23]
    |       |   |       |   |   `--EXPR -> EXPR [460:32]
    |       |   |       |   |       `--PLUS -> + [460:32]
    |       |   |       |   |           |--STRING_LITERAL -> "0" [460:28]
    |       |   |       |   |           `--IDENT -> i [460:34]
    |       |   |       |   `--SEMI -> ; [460:35]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [461:12]
    |       |   |       |   |--LITERAL_CASE -> case [461:12]
    |       |   |       |   |   `--EXPR -> EXPR [461:17]
    |       |   |       |   |       `--NUM_INT -> 1 [461:17]
    |       |   |       |   |--LAMBDA -> -> [461:19]
    |       |   |       |   |--LAMBDA -> -> [461:25]
    |       |   |       |   |   |--LPAREN -> ( [461:22]
    |       |   |       |   |   |--PARAMETERS -> PARAMETERS [461:23]
    |       |   |       |   |   |--RPAREN -> ) [461:23]
    |       |   |       |   |   `--EXPR -> EXPR [461:32]
    |       |   |       |   |       `--PLUS -> + [461:32]
    |       |   |       |   |           |--STRING_LITERAL -> "1" [461:28]
    |       |   |       |   |           `--IDENT -> j [461:34]
    |       |   |       |   `--SEMI -> ; [461:35]
    |       |   |       |--SWITCH_RULE -> SWITCH_RULE [462:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [462:12]
    |       |   |       |   |--LAMBDA -> -> [462:20]
    |       |   |       |   `--SLIST -> { [462:23]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [463:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [463:16]
    |       |   |       |       |   |--TYPE -> TYPE [463:16]
    |       |   |       |       |   |   `--IDENT -> String [463:16]
    |       |   |       |       |   |--IDENT -> k [463:23]
    |       |   |       |       |   `--ASSIGN -> = [463:25]
    |       |   |       |       |       `--EXPR -> EXPR [463:27]
    |       |   |       |       |           `--STRING_LITERAL -> "D" [463:27]
    |       |   |       |       |--SEMI -> ; [463:30]
    |       |   |       |       |--LITERAL_YIELD -> yield [464:16]
    |       |   |       |       |   |--LAMBDA -> -> [464:25]
    |       |   |       |       |   |   |--LPAREN -> ( [464:22]
    |       |   |       |       |   |   |--PARAMETERS -> PARAMETERS [464:23]
    |       |   |       |       |   |   |--RPAREN -> ) [464:23]
    |       |   |       |       |   |   `--EXPR -> EXPR [464:28]
    |       |   |       |       |   |       `--IDENT -> k [464:28]
    |       |   |       |       |   `--SEMI -> ; [464:29]
    |       |   |       |       `--RCURLY -> } [465:12]
    |       |   |       `--RCURLY -> } [466:8]
    |       |   `--SEMI -> ; [466:9]
    |       `--RCURLY -> } [467:4]
    |--INTERFACE_DEF -> INTERFACE_DEF [469:4]
    |   |--MODIFIERS -> MODIFIERS [469:4]
    |   |--LITERAL_INTERFACE -> interface [469:4]
    |   |--IDENT -> I [469:14]
    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [469:15]
    |   |   |--GENERIC_START -> < [469:15]
    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [469:16]
    |   |   |   `--IDENT -> T [469:16]
    |   |   `--GENERIC_END -> > [469:17]
    |   `--OBJBLOCK -> OBJBLOCK [469:19]
    |       |--LCURLY -> { [469:19]
    |       |--METHOD_DEF -> METHOD_DEF [470:8]
    |       |   |--MODIFIERS -> MODIFIERS [470:8]
    |       |   |   `--LITERAL_PUBLIC -> public [470:8]
    |       |   |--TYPE -> TYPE [470:15]
    |       |   |   `--IDENT -> T [470:15]
    |       |   |--IDENT -> t [470:17]
    |       |   |--LPAREN -> ( [470:18]
    |       |   |--PARAMETERS -> PARAMETERS [470:19]
    |       |   |--RPAREN -> ) [470:19]
    |       |   `--SEMI -> ; [470:20]
    |       `--RCURLY -> } [471:4]
    |--STATIC_INIT -> STATIC_INIT [473:4]
    |   `--SLIST -> { [473:11]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [474:8]
    |       |   |--MODIFIERS -> MODIFIERS [474:8]
    |       |   |--TYPE -> TYPE [474:8]
    |       |   |   `--LITERAL_INT -> int [474:8]
    |       |   |--IDENT -> i [474:12]
    |       |   `--ASSIGN -> = [474:14]
    |       |       `--EXPR -> EXPR [474:16]
    |       |           `--NUM_INT -> 0 [474:16]
    |       |--SEMI -> ; [474:17]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [475:8]
    |       |   |--MODIFIERS -> MODIFIERS [475:8]
    |       |   |--TYPE -> TYPE [475:8]
    |       |   |   `--LITERAL_INT -> int [475:8]
    |       |   |--IDENT -> dummy [475:12]
    |       |   `--ASSIGN -> = [475:18]
    |       |       `--EXPR -> EXPR [475:22]
    |       |           `--PLUS -> + [475:22]
    |       |               |--NUM_INT -> 1 [475:20]
    |       |               `--LITERAL_SWITCH -> switch [475:24]
    |       |                   |--LPAREN -> ( [475:31]
    |       |                   |--EXPR -> EXPR [475:32]
    |       |                   |   `--IDENT -> i [475:32]
    |       |                   |--RPAREN -> ) [475:33]
    |       |                   |--LCURLY -> { [475:35]
    |       |                   |--CASE_GROUP -> CASE_GROUP [476:12]
    |       |                   |   |--LITERAL_CASE -> case [476:12]
    |       |                   |   |   |--EXPR -> EXPR [476:17]
    |       |                   |   |   |   `--UNARY_MINUS -> - [476:17]
    |       |                   |   |   |       `--NUM_INT -> 1 [476:18]
    |       |                   |   |   `--COLON -> : [476:19]
    |       |                   |   `--SLIST -> SLIST [476:21]
    |       |                   |       `--LITERAL_YIELD -> yield [476:21]
    |       |                   |           |--EXPR -> EXPR [476:27]
    |       |                   |           |   `--NUM_INT -> 1 [476:27]
    |       |                   |           `--SEMI -> ; [476:28]
    |       |                   |--CASE_GROUP -> CASE_GROUP [477:12]
    |       |                   |   |--LITERAL_DEFAULT -> default [477:12]
    |       |                   |   |   `--COLON -> : [477:19]
    |       |                   |   `--SLIST -> SLIST [478:17]
    |       |                   |       |--EXPR -> EXPR [478:17]
    |       |                   |       |   `--POST_INC -> ++ [478:17]
    |       |                   |       |       `--IDENT -> i [478:16]
    |       |                   |       |--SEMI -> ; [478:19]
    |       |                   |       `--LITERAL_YIELD -> yield [479:16]
    |       |                   |           |--EXPR -> EXPR [479:22]
    |       |                   |           |   `--NUM_INT -> 1 [479:22]
    |       |                   |           `--SEMI -> ; [479:23]
    |       |                   `--RCURLY -> } [480:8]
    |       |--SEMI -> ; [480:9]
    |       |--LITERAL_IF -> if [481:8]
    |       |   |--LPAREN -> ( [481:11]
    |       |   |--EXPR -> EXPR [481:14]
    |       |   |   `--NOT_EQUAL -> != [481:14]
    |       |   |       |--IDENT -> i [481:12]
    |       |   |       `--NUM_INT -> 1 [481:17]
    |       |   |--RPAREN -> ) [481:18]
    |       |   `--SLIST -> { [481:20]
    |       |       |--LITERAL_THROW -> throw [482:12]
    |       |       |   |--EXPR -> EXPR [482:18]
    |       |       |   |   `--LITERAL_NEW -> new [482:18]
    |       |       |   |       |--IDENT -> IllegalStateException [482:22]
    |       |       |   |       |--LPAREN -> ( [482:43]
    |       |       |   |       |--ELIST -> ELIST [482:44]
    |       |       |   |       |   `--EXPR -> EXPR [482:44]
    |       |       |   |       |       `--STRING_LITERAL -> "Side effects missing." [482:44]
    |       |       |   |       `--RPAREN -> ) [482:67]
    |       |       |   `--SEMI -> ; [482:68]
    |       |       `--RCURLY -> } [483:8]
    |       `--RCURLY -> } [484:4]
    |--METHOD_DEF -> METHOD_DEF [486:4]
    |   |--MODIFIERS -> MODIFIERS [486:4]
    |   |   |--LITERAL_PRIVATE -> private [486:4]
    |   |   `--LITERAL_STATIC -> static [486:12]
    |   |--TYPE -> TYPE [486:19]
    |   |   `--LITERAL_INT -> int [486:19]
    |   |--IDENT -> getValueViaYield [486:23]
    |   |--LPAREN -> ( [486:39]
    |   |--PARAMETERS -> PARAMETERS [486:40]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [486:40]
    |   |       |--MODIFIERS -> MODIFIERS [486:40]
    |   |       |--TYPE -> TYPE [486:40]
    |   |       |   `--IDENT -> String [486:40]
    |   |       `--IDENT -> mode [486:47]
    |   |--RPAREN -> ) [486:51]
    |   `--SLIST -> { [486:53]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [487:8]
    |       |   |--MODIFIERS -> MODIFIERS [487:8]
    |       |   |--TYPE -> TYPE [487:8]
    |       |   |   `--LITERAL_INT -> int [487:8]
    |       |   |--IDENT -> yield [487:12]
    |       |   `--ASSIGN -> = [487:18]
    |       |       `--EXPR -> EXPR [487:20]
    |       |           `--NUM_INT -> 0 [487:20]
    |       |--SEMI -> ; [487:21]
    |       |--LITERAL_RETURN -> return [488:8]
    |       |   |--EXPR -> EXPR [488:15]
    |       |   |   `--LITERAL_SWITCH -> switch [488:15]
    |       |   |       |--LPAREN -> ( [488:22]
    |       |   |       |--EXPR -> EXPR [488:23]
    |       |   |       |   `--IDENT -> mode [488:23]
    |       |   |       |--RPAREN -> ) [488:27]
    |       |   |       |--LCURLY -> { [488:29]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [489:12]
    |       |   |       |   |--LITERAL_CASE -> case [489:12]
    |       |   |       |   |   |--EXPR -> EXPR [489:17]
    |       |   |       |   |   |   `--STRING_LITERAL -> "a" [489:17]
    |       |   |       |   |   |--COMMA -> , [489:20]
    |       |   |       |   |   |--EXPR -> EXPR [489:22]
    |       |   |       |   |   |   `--STRING_LITERAL -> "b" [489:22]
    |       |   |       |   |   `--COLON -> : [489:25]
    |       |   |       |   `--SLIST -> SLIST [490:16]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [490:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [490:16]
    |       |   |       |       |   |--TYPE -> TYPE [490:16]
    |       |   |       |       |   |   `--LITERAL_INT -> int [490:16]
    |       |   |       |       |   |--IDENT -> x [490:20]
    |       |   |       |       |   `--ASSIGN -> = [490:22]
    |       |   |       |       |       `--EXPR -> EXPR [490:30]
    |       |   |       |       |           `--PLUS -> + [490:30]
    |       |   |       |       |               |--IDENT -> yield [490:24]
    |       |   |       |       |               `--NUM_INT -> 2 [490:32]
    |       |   |       |       |--SEMI -> ; [490:33]
    |       |   |       |       `--LITERAL_YIELD -> yield [491:16]
    |       |   |       |           |--EXPR -> EXPR [491:22]
    |       |   |       |           |   `--IDENT -> x [491:22]
    |       |   |       |           `--SEMI -> ; [491:23]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [492:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [492:12]
    |       |   |       |   |   `--COLON -> : [492:19]
    |       |   |       |   `--SLIST -> SLIST [493:16]
    |       |   |       |       `--LITERAL_YIELD -> yield [493:16]
    |       |   |       |           |--EXPR -> EXPR [493:22]
    |       |   |       |           |   `--UNARY_MINUS -> - [493:22]
    |       |   |       |           |       `--NUM_INT -> 1 [493:24]
    |       |   |       |           `--SEMI -> ; [493:25]
    |       |   |       `--RCURLY -> } [494:8]
    |       |   `--SEMI -> ; [494:9]
    |       `--RCURLY -> } [495:4]
    |--METHOD_DEF -> METHOD_DEF [497:4]
    |   |--MODIFIERS -> MODIFIERS [497:4]
    |   |   |--LITERAL_PRIVATE -> private [497:4]
    |   |   `--LITERAL_STATIC -> static [497:12]
    |   |--TYPE -> TYPE [497:19]
    |   |   `--LITERAL_INT -> int [497:19]
    |   |--IDENT -> getValueViaYield2 [497:23]
    |   |--LPAREN -> ( [497:40]
    |   |--PARAMETERS -> PARAMETERS [497:41]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [497:41]
    |   |       |--MODIFIERS -> MODIFIERS [497:41]
    |   |       |--TYPE -> TYPE [497:41]
    |   |       |   `--IDENT -> String [497:41]
    |   |       `--IDENT -> mode [497:48]
    |   |--RPAREN -> ) [497:52]
    |   `--SLIST -> { [497:54]
    |       |--LITERAL_RETURN -> return [498:8]
    |       |   |--EXPR -> EXPR [498:15]
    |       |   |   `--LITERAL_SWITCH -> switch [498:15]
    |       |   |       |--LPAREN -> ( [498:22]
    |       |   |       |--EXPR -> EXPR [498:23]
    |       |   |       |   `--IDENT -> mode [498:23]
    |       |   |       |--RPAREN -> ) [498:27]
    |       |   |       |--LCURLY -> { [498:29]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [499:12]
    |       |   |       |   |--LITERAL_CASE -> case [499:12]
    |       |   |       |   |   |--EXPR -> EXPR [499:17]
    |       |   |       |   |   |   `--STRING_LITERAL -> "a" [499:17]
    |       |   |       |   |   |--COMMA -> , [499:20]
    |       |   |       |   |   |--EXPR -> EXPR [499:22]
    |       |   |       |   |   |   `--STRING_LITERAL -> "b" [499:22]
    |       |   |       |   |   `--COLON -> : [499:25]
    |       |   |       |   `--SLIST -> SLIST [500:16]
    |       |   |       |       |--VARIABLE_DEF -> VARIABLE_DEF [500:16]
    |       |   |       |       |   |--MODIFIERS -> MODIFIERS [500:16]
    |       |   |       |       |   |--TYPE -> TYPE [500:16]
    |       |   |       |       |   |   `--LITERAL_INT -> int [500:16]
    |       |   |       |       |   |--IDENT -> yield [500:20]
    |       |   |       |       |   `--ASSIGN -> = [500:26]
    |       |   |       |       |       `--EXPR -> EXPR [500:28]
    |       |   |       |       |           `--NUM_INT -> 42 [500:28]
    |       |   |       |       |--SEMI -> ; [500:30]
    |       |   |       |       `--LITERAL_YIELD -> yield [501:16]
    |       |   |       |           |--EXPR -> EXPR [501:22]
    |       |   |       |           |   `--IDENT -> yield [501:22]
    |       |   |       |           `--SEMI -> ; [501:27]
    |       |   |       |--CASE_GROUP -> CASE_GROUP [502:12]
    |       |   |       |   |--LITERAL_DEFAULT -> default [502:12]
    |       |   |       |   |   `--COLON -> : [502:19]
    |       |   |       |   `--SLIST -> SLIST [503:16]
    |       |   |       |       `--LITERAL_YIELD -> yield [503:16]
    |       |   |       |           |--EXPR -> EXPR [503:22]
    |       |   |       |           |   `--UNARY_MINUS -> - [503:22]
    |       |   |       |           |       `--NUM_INT -> 1 [503:24]
    |       |   |       |           `--SEMI -> ; [503:25]
    |       |   |       `--RCURLY -> } [504:8]
    |       |   `--SEMI -> ; [504:9]
    |       `--RCURLY -> } [505:4]
    `--RCURLY -> } [506:0]
