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