COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java19 [2:49]
|   `--SEMI -> ; [2:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputJava19BindingsWithLotsOfOperators [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:53]
        |--LCURLY -> { [4:53]
        |--METHOD_DEF -> METHOD_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |--TYPE -> TYPE [5:5]
        |   |   `--LITERAL_VOID -> void [5:5]
        |   |--IDENT -> m1 [5:10]
        |   |--LPAREN -> ( [5:12]
        |   |--PARAMETERS -> PARAMETERS [5:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [5:13]
        |   |       |--MODIFIERS -> MODIFIERS [5:13]
        |   |       |--TYPE -> TYPE [5:13]
        |   |       |   `--IDENT -> Object [5:13]
        |   |       `--IDENT -> o [5:20]
        |   |--RPAREN -> ) [5:21]
        |   `--SLIST -> { [5:23]
        |       |--LITERAL_SWITCH -> switch [6:9]
        |       |   |--LPAREN -> ( [6:16]
        |       |   |--EXPR -> EXPR [6:17]
        |       |   |   `--IDENT -> o [6:17]
        |       |   |--RPAREN -> ) [6:18]
        |       |   |--LCURLY -> { [6:20]
        |       |   |--CASE_GROUP -> CASE_GROUP [7:13]
        |       |   |   |--LITERAL_CASE -> case [7:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [7:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [7:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [7:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [7:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [7:18]
        |       |   |   |   |       |   `--IDENT -> i1 [7:26]
        |       |   |   |   |       `--EXPR -> EXPR [7:37]
        |       |   |   |   |           `--EQUAL -> == [7:37]
        |       |   |   |   |               |--IDENT -> i1 [7:34]
        |       |   |   |   |               `--NUM_INT -> 0 [7:40]
        |       |   |   |   `--COLON -> : [7:41]
        |       |   |   `--SLIST -> SLIST [7:45]
        |       |   |       |--EXPR -> EXPR [7:45]
        |       |   |       |   `--METHOD_CALL -> ( [7:45]
        |       |   |       |       |--IDENT -> m2 [7:43]
        |       |   |       |       |--ELIST -> ELIST [7:46]
        |       |   |       |       |   `--EXPR -> EXPR [7:46]
        |       |   |       |       |       `--IDENT -> i1 [7:46]
        |       |   |       |       `--RPAREN -> ) [7:48]
        |       |   |       |--SEMI -> ; [7:49]
        |       |   |       `--LITERAL_BREAK -> break [7:51]
        |       |   |           `--SEMI -> ; [7:56]
        |       |   |--CASE_GROUP -> CASE_GROUP [8:13]
        |       |   |   |--LITERAL_CASE -> case [8:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [8:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [8:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [8:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [8:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [8:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [8:18]
        |       |   |   |   |       |   `--IDENT -> i1 [8:26]
        |       |   |   |   |       `--EXPR -> EXPR [8:37]
        |       |   |   |   |           `--NOT_EQUAL -> != [8:37]
        |       |   |   |   |               |--IDENT -> i1 [8:34]
        |       |   |   |   |               `--NUM_INT -> 0 [8:40]
        |       |   |   |   `--COLON -> : [8:41]
        |       |   |   `--SLIST -> SLIST [8:45]
        |       |   |       |--EXPR -> EXPR [8:45]
        |       |   |       |   `--METHOD_CALL -> ( [8:45]
        |       |   |       |       |--IDENT -> m2 [8:43]
        |       |   |       |       |--ELIST -> ELIST [8:46]
        |       |   |       |       |   `--EXPR -> EXPR [8:46]
        |       |   |       |       |       `--IDENT -> i1 [8:46]
        |       |   |       |       `--RPAREN -> ) [8:48]
        |       |   |       |--SEMI -> ; [8:49]
        |       |   |       `--LITERAL_BREAK -> break [8:51]
        |       |   |           `--SEMI -> ; [8:56]
        |       |   |--CASE_GROUP -> CASE_GROUP [9:13]
        |       |   |   |--LITERAL_CASE -> case [9:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [9:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [9:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [9:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [9:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [9:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [9:18]
        |       |   |   |   |       |   `--IDENT -> i1 [9:26]
        |       |   |   |   |       `--EXPR -> EXPR [9:37]
        |       |   |   |   |           `--GT -> > [9:37]
        |       |   |   |   |               |--IDENT -> i1 [9:34]
        |       |   |   |   |               `--NUM_INT -> 0 [9:39]
        |       |   |   |   `--COLON -> : [9:40]
        |       |   |   `--SLIST -> SLIST [9:44]
        |       |   |       |--EXPR -> EXPR [9:44]
        |       |   |       |   `--METHOD_CALL -> ( [9:44]
        |       |   |       |       |--IDENT -> m2 [9:42]
        |       |   |       |       |--ELIST -> ELIST [9:45]
        |       |   |       |       |   `--EXPR -> EXPR [9:45]
        |       |   |       |       |       `--IDENT -> i1 [9:45]
        |       |   |       |       `--RPAREN -> ) [9:47]
        |       |   |       |--SEMI -> ; [9:48]
        |       |   |       `--LITERAL_BREAK -> break [9:50]
        |       |   |           `--SEMI -> ; [9:55]
        |       |   |--CASE_GROUP -> CASE_GROUP [10:13]
        |       |   |   |--LITERAL_CASE -> case [10:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [10:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [10:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [10:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [10:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [10:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [10:18]
        |       |   |   |   |       |   `--IDENT -> i1 [10:26]
        |       |   |   |   |       `--EXPR -> EXPR [10:37]
        |       |   |   |   |           `--GE -> >= [10:37]
        |       |   |   |   |               |--IDENT -> i1 [10:34]
        |       |   |   |   |               `--NUM_INT -> 0 [10:40]
        |       |   |   |   `--COLON -> : [10:41]
        |       |   |   `--SLIST -> SLIST [10:45]
        |       |   |       |--EXPR -> EXPR [10:45]
        |       |   |       |   `--METHOD_CALL -> ( [10:45]
        |       |   |       |       |--IDENT -> m2 [10:43]
        |       |   |       |       |--ELIST -> ELIST [10:46]
        |       |   |       |       |   `--EXPR -> EXPR [10:46]
        |       |   |       |       |       `--IDENT -> i1 [10:46]
        |       |   |       |       `--RPAREN -> ) [10:48]
        |       |   |       |--SEMI -> ; [10:49]
        |       |   |       `--LITERAL_BREAK -> break [10:51]
        |       |   |           `--SEMI -> ; [10:56]
        |       |   |--CASE_GROUP -> CASE_GROUP [11:13]
        |       |   |   |--LITERAL_CASE -> case [11:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [11:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [11:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [11:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [11:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [11:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [11:18]
        |       |   |   |   |       |   `--IDENT -> i1 [11:26]
        |       |   |   |   |       `--EXPR -> EXPR [11:37]
        |       |   |   |   |           `--LT -> < [11:37]
        |       |   |   |   |               |--IDENT -> i1 [11:34]
        |       |   |   |   |               `--NUM_INT -> 0 [11:39]
        |       |   |   |   `--COLON -> : [11:40]
        |       |   |   `--SLIST -> SLIST [11:44]
        |       |   |       |--EXPR -> EXPR [11:44]
        |       |   |       |   `--METHOD_CALL -> ( [11:44]
        |       |   |       |       |--IDENT -> m2 [11:42]
        |       |   |       |       |--ELIST -> ELIST [11:45]
        |       |   |       |       |   `--EXPR -> EXPR [11:45]
        |       |   |       |       |       `--IDENT -> i1 [11:45]
        |       |   |       |       `--RPAREN -> ) [11:47]
        |       |   |       |--SEMI -> ; [11:48]
        |       |   |       `--LITERAL_BREAK -> break [11:50]
        |       |   |           `--SEMI -> ; [11:55]
        |       |   |--CASE_GROUP -> CASE_GROUP [12:13]
        |       |   |   |--LITERAL_CASE -> case [12:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [12:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [12:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [12:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [12:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [12:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [12:18]
        |       |   |   |   |       |   `--IDENT -> i1 [12:26]
        |       |   |   |   |       `--EXPR -> EXPR [12:37]
        |       |   |   |   |           `--LE -> <= [12:37]
        |       |   |   |   |               |--IDENT -> i1 [12:34]
        |       |   |   |   |               `--NUM_INT -> 0 [12:40]
        |       |   |   |   `--COLON -> : [12:41]
        |       |   |   `--SLIST -> SLIST [12:45]
        |       |   |       |--EXPR -> EXPR [12:45]
        |       |   |       |   `--METHOD_CALL -> ( [12:45]
        |       |   |       |       |--IDENT -> m2 [12:43]
        |       |   |       |       |--ELIST -> ELIST [12:46]
        |       |   |       |       |   `--EXPR -> EXPR [12:46]
        |       |   |       |       |       `--IDENT -> i1 [12:46]
        |       |   |       |       `--RPAREN -> ) [12:48]
        |       |   |       |--SEMI -> ; [12:49]
        |       |   |       `--LITERAL_BREAK -> break [12:51]
        |       |   |           `--SEMI -> ; [12:56]
        |       |   |--CASE_GROUP -> CASE_GROUP [14:13]
        |       |   |   |--LITERAL_CASE -> case [14:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [14:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [14:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [14:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [14:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [14:18]
        |       |   |   |   |       |   `--IDENT -> i1 [14:26]
        |       |   |   |   |       `--EXPR -> EXPR [14:43]
        |       |   |   |   |           `--EQUAL -> == [14:43]
        |       |   |   |   |               |--LPAREN -> ( [14:34]
        |       |   |   |   |               |--BAND -> & [14:38]
        |       |   |   |   |               |   |--IDENT -> i1 [14:35]
        |       |   |   |   |               |   `--NUM_INT -> 0 [14:40]
        |       |   |   |   |               |--RPAREN -> ) [14:41]
        |       |   |   |   |               `--NUM_INT -> 0 [14:46]
        |       |   |   |   `--COLON -> : [14:47]
        |       |   |   `--SLIST -> SLIST [14:51]
        |       |   |       |--EXPR -> EXPR [14:51]
        |       |   |       |   `--METHOD_CALL -> ( [14:51]
        |       |   |       |       |--IDENT -> m2 [14:49]
        |       |   |       |       |--ELIST -> ELIST [14:52]
        |       |   |       |       |   `--EXPR -> EXPR [14:52]
        |       |   |       |       |       `--IDENT -> i1 [14:52]
        |       |   |       |       `--RPAREN -> ) [14:54]
        |       |   |       |--SEMI -> ; [14:55]
        |       |   |       `--LITERAL_BREAK -> break [14:57]
        |       |   |           `--SEMI -> ; [14:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [15:13]
        |       |   |   |--LITERAL_CASE -> case [15:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [15:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [15:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [15:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [15:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [15:18]
        |       |   |   |   |       |   `--IDENT -> i1 [15:26]
        |       |   |   |   |       `--EXPR -> EXPR [15:43]
        |       |   |   |   |           `--EQUAL -> == [15:43]
        |       |   |   |   |               |--LPAREN -> ( [15:34]
        |       |   |   |   |               |--BOR -> | [15:38]
        |       |   |   |   |               |   |--IDENT -> i1 [15:35]
        |       |   |   |   |               |   `--NUM_INT -> 0 [15:40]
        |       |   |   |   |               |--RPAREN -> ) [15:41]
        |       |   |   |   |               `--NUM_INT -> 0 [15:46]
        |       |   |   |   `--COLON -> : [15:47]
        |       |   |   `--SLIST -> SLIST [15:51]
        |       |   |       |--EXPR -> EXPR [15:51]
        |       |   |       |   `--METHOD_CALL -> ( [15:51]
        |       |   |       |       |--IDENT -> m2 [15:49]
        |       |   |       |       |--ELIST -> ELIST [15:52]
        |       |   |       |       |   `--EXPR -> EXPR [15:52]
        |       |   |       |       |       `--IDENT -> i1 [15:52]
        |       |   |       |       `--RPAREN -> ) [15:54]
        |       |   |       |--SEMI -> ; [15:55]
        |       |   |       `--LITERAL_BREAK -> break [15:57]
        |       |   |           `--SEMI -> ; [15:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [16:13]
        |       |   |   |--LITERAL_CASE -> case [16:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [16:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [16:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [16:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [16:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [16:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [16:18]
        |       |   |   |   |       |   `--IDENT -> i1 [16:26]
        |       |   |   |   |       `--EXPR -> EXPR [16:38]
        |       |   |   |   |           `--EQUAL -> == [16:38]
        |       |   |   |   |               |--BNOT -> ~ [16:34]
        |       |   |   |   |               |   `--IDENT -> i1 [16:35]
        |       |   |   |   |               `--NUM_INT -> 0 [16:41]
        |       |   |   |   `--COLON -> : [16:42]
        |       |   |   `--SLIST -> SLIST [16:46]
        |       |   |       |--EXPR -> EXPR [16:46]
        |       |   |       |   `--METHOD_CALL -> ( [16:46]
        |       |   |       |       |--IDENT -> m2 [16:44]
        |       |   |       |       |--ELIST -> ELIST [16:47]
        |       |   |       |       |   `--EXPR -> EXPR [16:47]
        |       |   |       |       |       `--IDENT -> i1 [16:47]
        |       |   |       |       `--RPAREN -> ) [16:49]
        |       |   |       |--SEMI -> ; [16:50]
        |       |   |       `--LITERAL_BREAK -> break [16:52]
        |       |   |           `--SEMI -> ; [16:57]
        |       |   |--CASE_GROUP -> CASE_GROUP [17:13]
        |       |   |   |--LITERAL_CASE -> case [17:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [17:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [17:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [17:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [17:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [17:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [17:18]
        |       |   |   |   |       |   `--IDENT -> i1 [17:26]
        |       |   |   |   |       `--EXPR -> EXPR [17:42]
        |       |   |   |   |           `--EQUAL -> == [17:42]
        |       |   |   |   |               |--SL -> << [17:37]
        |       |   |   |   |               |   |--IDENT -> i1 [17:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [17:40]
        |       |   |   |   |               `--NUM_INT -> 0 [17:45]
        |       |   |   |   `--COLON -> : [17:46]
        |       |   |   `--SLIST -> SLIST [17:50]
        |       |   |       |--EXPR -> EXPR [17:50]
        |       |   |       |   `--METHOD_CALL -> ( [17:50]
        |       |   |       |       |--IDENT -> m2 [17:48]
        |       |   |       |       |--ELIST -> ELIST [17:51]
        |       |   |       |       |   `--EXPR -> EXPR [17:51]
        |       |   |       |       |       `--IDENT -> i1 [17:51]
        |       |   |       |       `--RPAREN -> ) [17:53]
        |       |   |       |--SEMI -> ; [17:54]
        |       |   |       `--LITERAL_BREAK -> break [17:56]
        |       |   |           `--SEMI -> ; [17:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [18:13]
        |       |   |   |--LITERAL_CASE -> case [18:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [18:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [18:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [18:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [18:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [18:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [18:18]
        |       |   |   |   |       |   `--IDENT -> i1 [18:26]
        |       |   |   |   |       `--EXPR -> EXPR [18:42]
        |       |   |   |   |           `--EQUAL -> == [18:42]
        |       |   |   |   |               |--SR -> >> [18:37]
        |       |   |   |   |               |   |--IDENT -> i1 [18:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [18:40]
        |       |   |   |   |               `--NUM_INT -> 0 [18:45]
        |       |   |   |   `--COLON -> : [18:46]
        |       |   |   `--SLIST -> SLIST [18:50]
        |       |   |       |--EXPR -> EXPR [18:50]
        |       |   |       |   `--METHOD_CALL -> ( [18:50]
        |       |   |       |       |--IDENT -> m2 [18:48]
        |       |   |       |       |--ELIST -> ELIST [18:51]
        |       |   |       |       |   `--EXPR -> EXPR [18:51]
        |       |   |       |       |       `--IDENT -> i1 [18:51]
        |       |   |       |       `--RPAREN -> ) [18:53]
        |       |   |       |--SEMI -> ; [18:54]
        |       |   |       `--LITERAL_BREAK -> break [18:56]
        |       |   |           `--SEMI -> ; [18:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [19:13]
        |       |   |   |--LITERAL_CASE -> case [19:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [19:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [19:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [19:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [19:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [19:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [19:18]
        |       |   |   |   |       |   `--IDENT -> i1 [19:26]
        |       |   |   |   |       `--EXPR -> EXPR [19:43]
        |       |   |   |   |           `--EQUAL -> == [19:43]
        |       |   |   |   |               |--BSR -> >>> [19:37]
        |       |   |   |   |               |   |--IDENT -> i1 [19:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [19:41]
        |       |   |   |   |               `--NUM_INT -> 0 [19:46]
        |       |   |   |   `--COLON -> : [19:47]
        |       |   |   `--SLIST -> SLIST [19:51]
        |       |   |       |--EXPR -> EXPR [19:51]
        |       |   |       |   `--METHOD_CALL -> ( [19:51]
        |       |   |       |       |--IDENT -> m2 [19:49]
        |       |   |       |       |--ELIST -> ELIST [19:52]
        |       |   |       |       |   `--EXPR -> EXPR [19:52]
        |       |   |       |       |       `--IDENT -> i1 [19:52]
        |       |   |       |       `--RPAREN -> ) [19:54]
        |       |   |       |--SEMI -> ; [19:55]
        |       |   |       `--LITERAL_BREAK -> break [19:57]
        |       |   |           `--SEMI -> ; [19:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [20:13]
        |       |   |   |--LITERAL_CASE -> case [20:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [20:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [20:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [20:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [20:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [20:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [20:18]
        |       |   |   |   |       |   `--IDENT -> i1 [20:26]
        |       |   |   |   |       `--EXPR -> EXPR [20:43]
        |       |   |   |   |           `--EQUAL -> == [20:43]
        |       |   |   |   |               |--LPAREN -> ( [20:34]
        |       |   |   |   |               |--BXOR -> ^ [20:38]
        |       |   |   |   |               |   |--IDENT -> i1 [20:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [20:40]
        |       |   |   |   |               |--RPAREN -> ) [20:41]
        |       |   |   |   |               `--NUM_INT -> 0 [20:46]
        |       |   |   |   `--COLON -> : [20:47]
        |       |   |   `--SLIST -> SLIST [20:51]
        |       |   |       |--EXPR -> EXPR [20:51]
        |       |   |       |   `--METHOD_CALL -> ( [20:51]
        |       |   |       |       |--IDENT -> m2 [20:49]
        |       |   |       |       |--ELIST -> ELIST [20:52]
        |       |   |       |       |   `--EXPR -> EXPR [20:52]
        |       |   |       |       |       `--IDENT -> i1 [20:52]
        |       |   |       |       `--RPAREN -> ) [20:54]
        |       |   |       |--SEMI -> ; [20:55]
        |       |   |       `--LITERAL_BREAK -> break [20:57]
        |       |   |           `--SEMI -> ; [20:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [21:13]
        |       |   |   |--LITERAL_CASE -> case [21:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [21:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [21:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [21:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [21:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [21:18]
        |       |   |   |   |       |   `--IDENT -> i1 [21:26]
        |       |   |   |   |       `--EXPR -> EXPR [21:37]
        |       |   |   |   |           `--LITERAL_INSTANCEOF -> instanceof [21:37]
        |       |   |   |   |               |--IDENT -> i1 [21:34]
        |       |   |   |   |               `--TYPE -> TYPE [21:48]
        |       |   |   |   |                   `--IDENT -> Number [21:48]
        |       |   |   |   `--COLON -> : [21:54]
        |       |   |   `--SLIST -> SLIST [21:58]
        |       |   |       |--EXPR -> EXPR [21:58]
        |       |   |       |   `--METHOD_CALL -> ( [21:58]
        |       |   |       |       |--IDENT -> m2 [21:56]
        |       |   |       |       |--ELIST -> ELIST [21:59]
        |       |   |       |       |   `--EXPR -> EXPR [21:59]
        |       |   |       |       |       `--IDENT -> i1 [21:59]
        |       |   |       |       `--RPAREN -> ) [21:61]
        |       |   |       |--SEMI -> ; [21:62]
        |       |   |       `--LITERAL_BREAK -> break [21:64]
        |       |   |           `--SEMI -> ; [21:69]
        |       |   |--CASE_GROUP -> CASE_GROUP [22:13]
        |       |   |   |--LITERAL_CASE -> case [22:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [22:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [22:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [22:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [22:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [22:18]
        |       |   |   |   |       |   `--IDENT -> i1 [22:26]
        |       |   |   |   |       `--EXPR -> EXPR [22:39]
        |       |   |   |   |           `--EQUAL -> == [22:39]
        |       |   |   |   |               |--DEC -> -- [22:34]
        |       |   |   |   |               |   `--IDENT -> i1 [22:36]
        |       |   |   |   |               `--NUM_INT -> 0 [22:42]
        |       |   |   |   `--COLON -> : [22:43]
        |       |   |   `--SLIST -> SLIST [22:47]
        |       |   |       |--EXPR -> EXPR [22:47]
        |       |   |       |   `--METHOD_CALL -> ( [22:47]
        |       |   |       |       |--IDENT -> m2 [22:45]
        |       |   |       |       |--ELIST -> ELIST [22:48]
        |       |   |       |       |   `--EXPR -> EXPR [22:48]
        |       |   |       |       |       `--IDENT -> i1 [22:48]
        |       |   |       |       `--RPAREN -> ) [22:50]
        |       |   |       |--SEMI -> ; [22:51]
        |       |   |       `--LITERAL_BREAK -> break [22:53]
        |       |   |           `--SEMI -> ; [22:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [23:13]
        |       |   |   |--LITERAL_CASE -> case [23:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [23:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [23:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [23:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [23:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [23:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [23:18]
        |       |   |   |   |       |   `--IDENT -> i1 [23:26]
        |       |   |   |   |       `--EXPR -> EXPR [23:39]
        |       |   |   |   |           `--EQUAL -> == [23:39]
        |       |   |   |   |               |--INC -> ++ [23:34]
        |       |   |   |   |               |   `--IDENT -> i1 [23:36]
        |       |   |   |   |               `--NUM_INT -> 0 [23:42]
        |       |   |   |   `--COLON -> : [23:43]
        |       |   |   `--SLIST -> SLIST [23:47]
        |       |   |       |--EXPR -> EXPR [23:47]
        |       |   |       |   `--METHOD_CALL -> ( [23:47]
        |       |   |       |       |--IDENT -> m2 [23:45]
        |       |   |       |       |--ELIST -> ELIST [23:48]
        |       |   |       |       |   `--EXPR -> EXPR [23:48]
        |       |   |       |       |       `--IDENT -> i1 [23:48]
        |       |   |       |       `--RPAREN -> ) [23:50]
        |       |   |       |--SEMI -> ; [23:51]
        |       |   |       `--LITERAL_BREAK -> break [23:53]
        |       |   |           `--SEMI -> ; [23:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [24:13]
        |       |   |   |--LITERAL_CASE -> case [24:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [24:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [24:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [24:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [24:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [24:18]
        |       |   |   |   |       |   `--IDENT -> i1 [24:26]
        |       |   |   |   |       `--EXPR -> EXPR [24:39]
        |       |   |   |   |           `--EQUAL -> == [24:39]
        |       |   |   |   |               |--POST_DEC -> -- [24:36]
        |       |   |   |   |               |   `--IDENT -> i1 [24:34]
        |       |   |   |   |               `--NUM_INT -> 0 [24:42]
        |       |   |   |   `--COLON -> : [24:43]
        |       |   |   `--SLIST -> SLIST [24:47]
        |       |   |       |--EXPR -> EXPR [24:47]
        |       |   |       |   `--METHOD_CALL -> ( [24:47]
        |       |   |       |       |--IDENT -> m2 [24:45]
        |       |   |       |       |--ELIST -> ELIST [24:48]
        |       |   |       |       |   `--EXPR -> EXPR [24:48]
        |       |   |       |       |       `--IDENT -> i1 [24:48]
        |       |   |       |       `--RPAREN -> ) [24:50]
        |       |   |       |--SEMI -> ; [24:51]
        |       |   |       `--LITERAL_BREAK -> break [24:53]
        |       |   |           `--SEMI -> ; [24:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [25:13]
        |       |   |   |--LITERAL_CASE -> case [25:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [25:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [25:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [25:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [25:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [25:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [25:18]
        |       |   |   |   |       |   `--IDENT -> i1 [25:26]
        |       |   |   |   |       `--EXPR -> EXPR [25:39]
        |       |   |   |   |           `--EQUAL -> == [25:39]
        |       |   |   |   |               |--POST_INC -> ++ [25:36]
        |       |   |   |   |               |   `--IDENT -> i1 [25:34]
        |       |   |   |   |               `--NUM_INT -> 0 [25:42]
        |       |   |   |   `--COLON -> : [25:43]
        |       |   |   `--SLIST -> SLIST [25:47]
        |       |   |       |--EXPR -> EXPR [25:47]
        |       |   |       |   `--METHOD_CALL -> ( [25:47]
        |       |   |       |       |--IDENT -> m2 [25:45]
        |       |   |       |       |--ELIST -> ELIST [25:48]
        |       |   |       |       |   `--EXPR -> EXPR [25:48]
        |       |   |       |       |       `--IDENT -> i1 [25:48]
        |       |   |       |       `--RPAREN -> ) [25:50]
        |       |   |       |--SEMI -> ; [25:51]
        |       |   |       `--LITERAL_BREAK -> break [25:53]
        |       |   |           `--SEMI -> ; [25:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [26:13]
        |       |   |   |--LITERAL_CASE -> case [26:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [26:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [26:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [26:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [26:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [26:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [26:18]
        |       |   |   |   |       |   `--IDENT -> i1 [26:26]
        |       |   |   |   |       `--EXPR -> EXPR [26:40]
        |       |   |   |   |           `--EQUAL -> == [26:40]
        |       |   |   |   |               |--PLUS -> + [26:37]
        |       |   |   |   |               |   |--IDENT -> i1 [26:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [26:39]
        |       |   |   |   |               `--NUM_INT -> 0 [26:43]
        |       |   |   |   `--COLON -> : [26:44]
        |       |   |   `--SLIST -> SLIST [26:48]
        |       |   |       |--EXPR -> EXPR [26:48]
        |       |   |       |   `--METHOD_CALL -> ( [26:48]
        |       |   |       |       |--IDENT -> m2 [26:46]
        |       |   |       |       |--ELIST -> ELIST [26:49]
        |       |   |       |       |   `--EXPR -> EXPR [26:49]
        |       |   |       |       |       `--IDENT -> i1 [26:49]
        |       |   |       |       `--RPAREN -> ) [26:51]
        |       |   |       |--SEMI -> ; [26:52]
        |       |   |       `--LITERAL_BREAK -> break [26:54]
        |       |   |           `--SEMI -> ; [26:59]
        |       |   |--CASE_GROUP -> CASE_GROUP [27:13]
        |       |   |   |--LITERAL_CASE -> case [27:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [27:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [27:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [27:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [27:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [27:18]
        |       |   |   |   |       |   `--IDENT -> i1 [27:26]
        |       |   |   |   |       `--EXPR -> EXPR [27:41]
        |       |   |   |   |           `--EQUAL -> == [27:41]
        |       |   |   |   |               |--MINUS -> - [27:37]
        |       |   |   |   |               |   |--IDENT -> i1 [27:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [27:39]
        |       |   |   |   |               `--NUM_INT -> 0 [27:44]
        |       |   |   |   `--COLON -> : [27:45]
        |       |   |   `--SLIST -> SLIST [27:49]
        |       |   |       |--EXPR -> EXPR [27:49]
        |       |   |       |   `--METHOD_CALL -> ( [27:49]
        |       |   |       |       |--IDENT -> m2 [27:47]
        |       |   |       |       |--ELIST -> ELIST [27:50]
        |       |   |       |       |   `--EXPR -> EXPR [27:50]
        |       |   |       |       |       `--IDENT -> i1 [27:50]
        |       |   |       |       `--RPAREN -> ) [27:52]
        |       |   |       |--SEMI -> ; [27:53]
        |       |   |       `--LITERAL_BREAK -> break [27:55]
        |       |   |           `--SEMI -> ; [27:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [28:13]
        |       |   |   |--LITERAL_CASE -> case [28:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [28:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [28:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [28:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [28:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [28:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [28:18]
        |       |   |   |   |       |   `--IDENT -> i1 [28:26]
        |       |   |   |   |       `--EXPR -> EXPR [28:41]
        |       |   |   |   |           `--EQUAL -> == [28:41]
        |       |   |   |   |               |--DIV -> / [28:37]
        |       |   |   |   |               |   |--IDENT -> i1 [28:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [28:39]
        |       |   |   |   |               `--NUM_INT -> 0 [28:44]
        |       |   |   |   `--COLON -> : [28:45]
        |       |   |   `--SLIST -> SLIST [28:49]
        |       |   |       |--EXPR -> EXPR [28:49]
        |       |   |       |   `--METHOD_CALL -> ( [28:49]
        |       |   |       |       |--IDENT -> m2 [28:47]
        |       |   |       |       |--ELIST -> ELIST [28:50]
        |       |   |       |       |   `--EXPR -> EXPR [28:50]
        |       |   |       |       |       `--IDENT -> i1 [28:50]
        |       |   |       |       `--RPAREN -> ) [28:52]
        |       |   |       |--SEMI -> ; [28:53]
        |       |   |       `--LITERAL_BREAK -> break [28:55]
        |       |   |           `--SEMI -> ; [28:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [29:13]
        |       |   |   |--LITERAL_CASE -> case [29:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [29:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [29:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [29:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [29:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [29:18]
        |       |   |   |   |       |   `--IDENT -> i1 [29:26]
        |       |   |   |   |       `--EXPR -> EXPR [29:41]
        |       |   |   |   |           `--EQUAL -> == [29:41]
        |       |   |   |   |               |--STAR -> * [29:37]
        |       |   |   |   |               |   |--IDENT -> i1 [29:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [29:39]
        |       |   |   |   |               `--NUM_INT -> 0 [29:44]
        |       |   |   |   `--COLON -> : [29:45]
        |       |   |   `--SLIST -> SLIST [29:49]
        |       |   |       |--EXPR -> EXPR [29:49]
        |       |   |       |   `--METHOD_CALL -> ( [29:49]
        |       |   |       |       |--IDENT -> m2 [29:47]
        |       |   |       |       |--ELIST -> ELIST [29:50]
        |       |   |       |       |   `--EXPR -> EXPR [29:50]
        |       |   |       |       |       `--IDENT -> i1 [29:50]
        |       |   |       |       `--RPAREN -> ) [29:52]
        |       |   |       |--SEMI -> ; [29:53]
        |       |   |       `--LITERAL_BREAK -> break [29:55]
        |       |   |           `--SEMI -> ; [29:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [30:13]
        |       |   |   |--LITERAL_CASE -> case [30:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [30:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [30:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [30:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [30:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [30:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [30:18]
        |       |   |   |   |       |   `--IDENT -> i1 [30:26]
        |       |   |   |   |       `--EXPR -> EXPR [30:41]
        |       |   |   |   |           `--EQUAL -> == [30:41]
        |       |   |   |   |               |--MOD -> % [30:37]
        |       |   |   |   |               |   |--IDENT -> i1 [30:34]
        |       |   |   |   |               |   `--NUM_INT -> 2 [30:39]
        |       |   |   |   |               `--NUM_INT -> 0 [30:44]
        |       |   |   |   `--COLON -> : [30:45]
        |       |   |   `--SLIST -> SLIST [30:49]
        |       |   |       |--EXPR -> EXPR [30:49]
        |       |   |       |   `--METHOD_CALL -> ( [30:49]
        |       |   |       |       |--IDENT -> m2 [30:47]
        |       |   |       |       |--ELIST -> ELIST [30:50]
        |       |   |       |       |   `--EXPR -> EXPR [30:50]
        |       |   |       |       |       `--IDENT -> i1 [30:50]
        |       |   |       |       `--RPAREN -> ) [30:52]
        |       |   |       |--SEMI -> ; [30:53]
        |       |   |       `--LITERAL_BREAK -> break [30:55]
        |       |   |           `--SEMI -> ; [30:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [32:13]
        |       |   |   |--LITERAL_CASE -> case [32:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [32:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [32:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [32:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [32:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [32:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [32:18]
        |       |   |   |   |       |   `--IDENT -> i1 [32:26]
        |       |   |   |   |       `--EXPR -> EXPR [32:44]
        |       |   |   |   |           `--EQUAL -> == [32:44]
        |       |   |   |   |               |--LPAREN -> ( [32:34]
        |       |   |   |   |               |--BAND -> & [32:39]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [32:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [32:36]
        |       |   |   |   |               |   `--NUM_INT -> 0 [32:41]
        |       |   |   |   |               |--RPAREN -> ) [32:42]
        |       |   |   |   |               `--NUM_INT -> 0 [32:47]
        |       |   |   |   `--COLON -> : [32:48]
        |       |   |   `--SLIST -> SLIST [32:52]
        |       |   |       |--EXPR -> EXPR [32:52]
        |       |   |       |   `--METHOD_CALL -> ( [32:52]
        |       |   |       |       |--IDENT -> m2 [32:50]
        |       |   |       |       |--ELIST -> ELIST [32:53]
        |       |   |       |       |   `--EXPR -> EXPR [32:53]
        |       |   |       |       |       `--IDENT -> i1 [32:53]
        |       |   |       |       `--RPAREN -> ) [32:55]
        |       |   |       |--SEMI -> ; [32:56]
        |       |   |       `--LITERAL_BREAK -> break [32:58]
        |       |   |           `--SEMI -> ; [32:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [33:13]
        |       |   |   |--LITERAL_CASE -> case [33:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [33:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [33:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [33:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [33:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [33:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [33:18]
        |       |   |   |   |       |   `--IDENT -> i1 [33:26]
        |       |   |   |   |       `--EXPR -> EXPR [33:44]
        |       |   |   |   |           `--EQUAL -> == [33:44]
        |       |   |   |   |               |--LPAREN -> ( [33:34]
        |       |   |   |   |               |--BOR -> | [33:39]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [33:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [33:36]
        |       |   |   |   |               |   `--NUM_INT -> 0 [33:41]
        |       |   |   |   |               |--RPAREN -> ) [33:42]
        |       |   |   |   |               `--NUM_INT -> 0 [33:47]
        |       |   |   |   `--COLON -> : [33:48]
        |       |   |   `--SLIST -> SLIST [33:52]
        |       |   |       |--EXPR -> EXPR [33:52]
        |       |   |       |   `--METHOD_CALL -> ( [33:52]
        |       |   |       |       |--IDENT -> m2 [33:50]
        |       |   |       |       |--ELIST -> ELIST [33:53]
        |       |   |       |       |   `--EXPR -> EXPR [33:53]
        |       |   |       |       |       `--IDENT -> i1 [33:53]
        |       |   |       |       `--RPAREN -> ) [33:55]
        |       |   |       |--SEMI -> ; [33:56]
        |       |   |       `--LITERAL_BREAK -> break [33:58]
        |       |   |           `--SEMI -> ; [33:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [34:13]
        |       |   |   |--LITERAL_CASE -> case [34:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [34:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [34:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [34:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [34:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [34:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [34:18]
        |       |   |   |   |       |   `--IDENT -> i1 [34:26]
        |       |   |   |   |       `--EXPR -> EXPR [34:39]
        |       |   |   |   |           `--EQUAL -> == [34:39]
        |       |   |   |   |               |--BNOT -> ~ [34:34]
        |       |   |   |   |               |   `--UNARY_PLUS -> + [34:35]
        |       |   |   |   |               |       `--IDENT -> i1 [34:36]
        |       |   |   |   |               `--NUM_INT -> 0 [34:42]
        |       |   |   |   `--COLON -> : [34:43]
        |       |   |   `--SLIST -> SLIST [34:47]
        |       |   |       |--EXPR -> EXPR [34:47]
        |       |   |       |   `--METHOD_CALL -> ( [34:47]
        |       |   |       |       |--IDENT -> m2 [34:45]
        |       |   |       |       |--ELIST -> ELIST [34:48]
        |       |   |       |       |   `--EXPR -> EXPR [34:48]
        |       |   |       |       |       `--IDENT -> i1 [34:48]
        |       |   |       |       `--RPAREN -> ) [34:50]
        |       |   |       |--SEMI -> ; [34:51]
        |       |   |       `--LITERAL_BREAK -> break [34:53]
        |       |   |           `--SEMI -> ; [34:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [35:13]
        |       |   |   |--LITERAL_CASE -> case [35:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [35:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [35:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [35:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [35:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [35:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [35:18]
        |       |   |   |   |       |   `--IDENT -> i1 [35:26]
        |       |   |   |   |       `--EXPR -> EXPR [35:43]
        |       |   |   |   |           `--EQUAL -> == [35:43]
        |       |   |   |   |               |--SL -> << [35:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [35:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [35:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [35:41]
        |       |   |   |   |               `--NUM_INT -> 0 [35:46]
        |       |   |   |   `--COLON -> : [35:47]
        |       |   |   `--SLIST -> SLIST [35:51]
        |       |   |       |--EXPR -> EXPR [35:51]
        |       |   |       |   `--METHOD_CALL -> ( [35:51]
        |       |   |       |       |--IDENT -> m2 [35:49]
        |       |   |       |       |--ELIST -> ELIST [35:52]
        |       |   |       |       |   `--EXPR -> EXPR [35:52]
        |       |   |       |       |       `--IDENT -> i1 [35:52]
        |       |   |       |       `--RPAREN -> ) [35:54]
        |       |   |       |--SEMI -> ; [35:55]
        |       |   |       `--LITERAL_BREAK -> break [35:57]
        |       |   |           `--SEMI -> ; [35:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [36:13]
        |       |   |   |--LITERAL_CASE -> case [36:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [36:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [36:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [36:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [36:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [36:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [36:18]
        |       |   |   |   |       |   `--IDENT -> i1 [36:26]
        |       |   |   |   |       `--EXPR -> EXPR [36:43]
        |       |   |   |   |           `--EQUAL -> == [36:43]
        |       |   |   |   |               |--SR -> >> [36:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [36:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [36:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [36:41]
        |       |   |   |   |               `--NUM_INT -> 0 [36:46]
        |       |   |   |   `--COLON -> : [36:47]
        |       |   |   `--SLIST -> SLIST [36:51]
        |       |   |       |--EXPR -> EXPR [36:51]
        |       |   |       |   `--METHOD_CALL -> ( [36:51]
        |       |   |       |       |--IDENT -> m2 [36:49]
        |       |   |       |       |--ELIST -> ELIST [36:52]
        |       |   |       |       |   `--EXPR -> EXPR [36:52]
        |       |   |       |       |       `--IDENT -> i1 [36:52]
        |       |   |       |       `--RPAREN -> ) [36:54]
        |       |   |       |--SEMI -> ; [36:55]
        |       |   |       `--LITERAL_BREAK -> break [36:57]
        |       |   |           `--SEMI -> ; [36:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [37:13]
        |       |   |   |--LITERAL_CASE -> case [37:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [37:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [37:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [37:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [37:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [37:18]
        |       |   |   |   |       |   `--IDENT -> i1 [37:26]
        |       |   |   |   |       `--EXPR -> EXPR [37:44]
        |       |   |   |   |           `--EQUAL -> == [37:44]
        |       |   |   |   |               |--BSR -> >>> [37:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [37:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [37:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [37:42]
        |       |   |   |   |               `--NUM_INT -> 0 [37:47]
        |       |   |   |   `--COLON -> : [37:48]
        |       |   |   `--SLIST -> SLIST [37:52]
        |       |   |       |--EXPR -> EXPR [37:52]
        |       |   |       |   `--METHOD_CALL -> ( [37:52]
        |       |   |       |       |--IDENT -> m2 [37:50]
        |       |   |       |       |--ELIST -> ELIST [37:53]
        |       |   |       |       |   `--EXPR -> EXPR [37:53]
        |       |   |       |       |       `--IDENT -> i1 [37:53]
        |       |   |       |       `--RPAREN -> ) [37:55]
        |       |   |       |--SEMI -> ; [37:56]
        |       |   |       `--LITERAL_BREAK -> break [37:58]
        |       |   |           `--SEMI -> ; [37:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [38:13]
        |       |   |   |--LITERAL_CASE -> case [38:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [38:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [38:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [38:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [38:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [38:18]
        |       |   |   |   |       |   `--IDENT -> i1 [38:26]
        |       |   |   |   |       `--EXPR -> EXPR [38:44]
        |       |   |   |   |           `--EQUAL -> == [38:44]
        |       |   |   |   |               |--LPAREN -> ( [38:34]
        |       |   |   |   |               |--BXOR -> ^ [38:39]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [38:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [38:36]
        |       |   |   |   |               |   `--NUM_INT -> 2 [38:41]
        |       |   |   |   |               |--RPAREN -> ) [38:42]
        |       |   |   |   |               `--NUM_INT -> 0 [38:47]
        |       |   |   |   `--COLON -> : [38:48]
        |       |   |   `--SLIST -> SLIST [38:52]
        |       |   |       |--EXPR -> EXPR [38:52]
        |       |   |       |   `--METHOD_CALL -> ( [38:52]
        |       |   |       |       |--IDENT -> m2 [38:50]
        |       |   |       |       |--ELIST -> ELIST [38:53]
        |       |   |       |       |   `--EXPR -> EXPR [38:53]
        |       |   |       |       |       `--IDENT -> i1 [38:53]
        |       |   |       |       `--RPAREN -> ) [38:55]
        |       |   |       |--SEMI -> ; [38:56]
        |       |   |       `--LITERAL_BREAK -> break [38:58]
        |       |   |           `--SEMI -> ; [38:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [39:13]
        |       |   |   |--LITERAL_CASE -> case [39:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [39:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [39:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [39:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [39:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [39:18]
        |       |   |   |   |       |   `--IDENT -> i1 [39:26]
        |       |   |   |   |       `--EXPR -> EXPR [39:37]
        |       |   |   |   |           `--LITERAL_INSTANCEOF -> instanceof [39:37]
        |       |   |   |   |               |--IDENT -> i1 [39:34]
        |       |   |   |   |               `--TYPE -> TYPE [39:48]
        |       |   |   |   |                   `--IDENT -> Number [39:48]
        |       |   |   |   `--COLON -> : [39:54]
        |       |   |   `--SLIST -> SLIST [39:58]
        |       |   |       |--EXPR -> EXPR [39:58]
        |       |   |       |   `--METHOD_CALL -> ( [39:58]
        |       |   |       |       |--IDENT -> m2 [39:56]
        |       |   |       |       |--ELIST -> ELIST [39:59]
        |       |   |       |       |   `--EXPR -> EXPR [39:59]
        |       |   |       |       |       `--IDENT -> i1 [39:59]
        |       |   |       |       `--RPAREN -> ) [39:61]
        |       |   |       |--SEMI -> ; [39:62]
        |       |   |       `--LITERAL_BREAK -> break [39:64]
        |       |   |           `--SEMI -> ; [39:69]
        |       |   |--CASE_GROUP -> CASE_GROUP [40:13]
        |       |   |   |--LITERAL_CASE -> case [40:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [40:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [40:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [40:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [40:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [40:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [40:18]
        |       |   |   |   |       |   `--IDENT -> i1 [40:26]
        |       |   |   |   |       `--EXPR -> EXPR [40:40]
        |       |   |   |   |           `--EQUAL -> == [40:40]
        |       |   |   |   |               |--UNARY_PLUS -> + [40:34]
        |       |   |   |   |               |   `--POST_DEC -> -- [40:37]
        |       |   |   |   |               |       `--IDENT -> i1 [40:35]
        |       |   |   |   |               `--NUM_INT -> 0 [40:43]
        |       |   |   |   `--COLON -> : [40:44]
        |       |   |   `--SLIST -> SLIST [40:48]
        |       |   |       |--EXPR -> EXPR [40:48]
        |       |   |       |   `--METHOD_CALL -> ( [40:48]
        |       |   |       |       |--IDENT -> m2 [40:46]
        |       |   |       |       |--ELIST -> ELIST [40:49]
        |       |   |       |       |   `--EXPR -> EXPR [40:49]
        |       |   |       |       |       `--IDENT -> i1 [40:49]
        |       |   |       |       `--RPAREN -> ) [40:51]
        |       |   |       |--SEMI -> ; [40:52]
        |       |   |       `--LITERAL_BREAK -> break [40:54]
        |       |   |           `--SEMI -> ; [40:59]
        |       |   |--CASE_GROUP -> CASE_GROUP [41:13]
        |       |   |   |--LITERAL_CASE -> case [41:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [41:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [41:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [41:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [41:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [41:18]
        |       |   |   |   |       |   `--IDENT -> i1 [41:26]
        |       |   |   |   |       `--EXPR -> EXPR [41:40]
        |       |   |   |   |           `--EQUAL -> == [41:40]
        |       |   |   |   |               |--UNARY_PLUS -> + [41:34]
        |       |   |   |   |               |   `--POST_INC -> ++ [41:37]
        |       |   |   |   |               |       `--IDENT -> i1 [41:35]
        |       |   |   |   |               `--NUM_INT -> 0 [41:43]
        |       |   |   |   `--COLON -> : [41:44]
        |       |   |   `--SLIST -> SLIST [41:48]
        |       |   |       |--EXPR -> EXPR [41:48]
        |       |   |       |   `--METHOD_CALL -> ( [41:48]
        |       |   |       |       |--IDENT -> m2 [41:46]
        |       |   |       |       |--ELIST -> ELIST [41:49]
        |       |   |       |       |   `--EXPR -> EXPR [41:49]
        |       |   |       |       |       `--IDENT -> i1 [41:49]
        |       |   |       |       `--RPAREN -> ) [41:51]
        |       |   |       |--SEMI -> ; [41:52]
        |       |   |       `--LITERAL_BREAK -> break [41:54]
        |       |   |           `--SEMI -> ; [41:59]
        |       |   |--CASE_GROUP -> CASE_GROUP [42:13]
        |       |   |   |--LITERAL_CASE -> case [42:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [42:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [42:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [42:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [42:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [42:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [42:18]
        |       |   |   |   |       |   `--IDENT -> i1 [42:26]
        |       |   |   |   |       `--EXPR -> EXPR [42:41]
        |       |   |   |   |           `--EQUAL -> == [42:41]
        |       |   |   |   |               |--PLUS -> + [42:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [42:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [42:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [42:40]
        |       |   |   |   |               `--NUM_INT -> 0 [42:44]
        |       |   |   |   `--COLON -> : [42:45]
        |       |   |   `--SLIST -> SLIST [42:49]
        |       |   |       |--EXPR -> EXPR [42:49]
        |       |   |       |   `--METHOD_CALL -> ( [42:49]
        |       |   |       |       |--IDENT -> m2 [42:47]
        |       |   |       |       |--ELIST -> ELIST [42:50]
        |       |   |       |       |   `--EXPR -> EXPR [42:50]
        |       |   |       |       |       `--IDENT -> i1 [42:50]
        |       |   |       |       `--RPAREN -> ) [42:52]
        |       |   |       |--SEMI -> ; [42:53]
        |       |   |       `--LITERAL_BREAK -> break [42:55]
        |       |   |           `--SEMI -> ; [42:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [43:13]
        |       |   |   |--LITERAL_CASE -> case [43:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [43:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [43:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [43:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [43:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [43:18]
        |       |   |   |   |       |   `--IDENT -> i1 [43:26]
        |       |   |   |   |       `--EXPR -> EXPR [43:42]
        |       |   |   |   |           `--EQUAL -> == [43:42]
        |       |   |   |   |               |--MINUS -> - [43:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [43:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [43:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [43:40]
        |       |   |   |   |               `--NUM_INT -> 0 [43:45]
        |       |   |   |   `--COLON -> : [43:46]
        |       |   |   `--SLIST -> SLIST [43:50]
        |       |   |       |--EXPR -> EXPR [43:50]
        |       |   |       |   `--METHOD_CALL -> ( [43:50]
        |       |   |       |       |--IDENT -> m2 [43:48]
        |       |   |       |       |--ELIST -> ELIST [43:51]
        |       |   |       |       |   `--EXPR -> EXPR [43:51]
        |       |   |       |       |       `--IDENT -> i1 [43:51]
        |       |   |       |       `--RPAREN -> ) [43:53]
        |       |   |       |--SEMI -> ; [43:54]
        |       |   |       `--LITERAL_BREAK -> break [43:56]
        |       |   |           `--SEMI -> ; [43:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [44:13]
        |       |   |   |--LITERAL_CASE -> case [44:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [44:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [44:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [44:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [44:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [44:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [44:18]
        |       |   |   |   |       |   `--IDENT -> i1 [44:26]
        |       |   |   |   |       `--EXPR -> EXPR [44:42]
        |       |   |   |   |           `--EQUAL -> == [44:42]
        |       |   |   |   |               |--DIV -> / [44:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [44:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [44:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [44:40]
        |       |   |   |   |               `--NUM_INT -> 0 [44:45]
        |       |   |   |   `--COLON -> : [44:46]
        |       |   |   `--SLIST -> SLIST [44:50]
        |       |   |       |--EXPR -> EXPR [44:50]
        |       |   |       |   `--METHOD_CALL -> ( [44:50]
        |       |   |       |       |--IDENT -> m2 [44:48]
        |       |   |       |       |--ELIST -> ELIST [44:51]
        |       |   |       |       |   `--EXPR -> EXPR [44:51]
        |       |   |       |       |       `--IDENT -> i1 [44:51]
        |       |   |       |       `--RPAREN -> ) [44:53]
        |       |   |       |--SEMI -> ; [44:54]
        |       |   |       `--LITERAL_BREAK -> break [44:56]
        |       |   |           `--SEMI -> ; [44:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [45:13]
        |       |   |   |--LITERAL_CASE -> case [45:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [45:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [45:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [45:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [45:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [45:18]
        |       |   |   |   |       |   `--IDENT -> i1 [45:26]
        |       |   |   |   |       `--EXPR -> EXPR [45:42]
        |       |   |   |   |           `--EQUAL -> == [45:42]
        |       |   |   |   |               |--STAR -> * [45:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [45:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [45:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [45:40]
        |       |   |   |   |               `--NUM_INT -> 0 [45:45]
        |       |   |   |   `--COLON -> : [45:46]
        |       |   |   `--SLIST -> SLIST [45:50]
        |       |   |       |--EXPR -> EXPR [45:50]
        |       |   |       |   `--METHOD_CALL -> ( [45:50]
        |       |   |       |       |--IDENT -> m2 [45:48]
        |       |   |       |       |--ELIST -> ELIST [45:51]
        |       |   |       |       |   `--EXPR -> EXPR [45:51]
        |       |   |       |       |       `--IDENT -> i1 [45:51]
        |       |   |       |       `--RPAREN -> ) [45:53]
        |       |   |       |--SEMI -> ; [45:54]
        |       |   |       `--LITERAL_BREAK -> break [45:56]
        |       |   |           `--SEMI -> ; [45:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [46:13]
        |       |   |   |--LITERAL_CASE -> case [46:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [46:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [46:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [46:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [46:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [46:18]
        |       |   |   |   |       |   `--IDENT -> i1 [46:26]
        |       |   |   |   |       `--EXPR -> EXPR [46:42]
        |       |   |   |   |           `--EQUAL -> == [46:42]
        |       |   |   |   |               |--MOD -> % [46:38]
        |       |   |   |   |               |   |--UNARY_PLUS -> + [46:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [46:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [46:40]
        |       |   |   |   |               `--NUM_INT -> 0 [46:45]
        |       |   |   |   `--COLON -> : [46:46]
        |       |   |   `--SLIST -> SLIST [46:50]
        |       |   |       |--EXPR -> EXPR [46:50]
        |       |   |       |   `--METHOD_CALL -> ( [46:50]
        |       |   |       |       |--IDENT -> m2 [46:48]
        |       |   |       |       |--ELIST -> ELIST [46:51]
        |       |   |       |       |   `--EXPR -> EXPR [46:51]
        |       |   |       |       |       `--IDENT -> i1 [46:51]
        |       |   |       |       `--RPAREN -> ) [46:53]
        |       |   |       |--SEMI -> ; [46:54]
        |       |   |       `--LITERAL_BREAK -> break [46:56]
        |       |   |           `--SEMI -> ; [46:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [47:13]
        |       |   |   |--LITERAL_CASE -> case [47:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [47:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [47:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [47:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [47:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [47:18]
        |       |   |   |   |       |   `--IDENT -> i1 [47:26]
        |       |   |   |   |       `--EXPR -> EXPR [47:47]
        |       |   |   |   |           `--EQUAL -> == [47:47]
        |       |   |   |   |               |--MOD -> % [47:43]
        |       |   |   |   |               |   |--TYPECAST -> ( [47:34]
        |       |   |   |   |               |   |   |--TYPE -> TYPE [47:35]
        |       |   |   |   |               |   |   |   `--LITERAL_INT -> int [47:35]
        |       |   |   |   |               |   |   |--RPAREN -> ) [47:38]
        |       |   |   |   |               |   |   `--UNARY_PLUS -> + [47:39]
        |       |   |   |   |               |   |       `--IDENT -> i1 [47:40]
        |       |   |   |   |               |   `--NUM_INT -> 2 [47:45]
        |       |   |   |   |               `--NUM_INT -> 0 [47:50]
        |       |   |   |   `--COLON -> : [47:51]
        |       |   |   `--SLIST -> SLIST [47:55]
        |       |   |       |--EXPR -> EXPR [47:55]
        |       |   |       |   `--METHOD_CALL -> ( [47:55]
        |       |   |       |       |--IDENT -> m2 [47:53]
        |       |   |       |       |--ELIST -> ELIST [47:56]
        |       |   |       |       |   `--EXPR -> EXPR [47:56]
        |       |   |       |       |       `--IDENT -> i1 [47:56]
        |       |   |       |       `--RPAREN -> ) [47:58]
        |       |   |       |--SEMI -> ; [47:59]
        |       |   |       `--LITERAL_BREAK -> break [47:61]
        |       |   |           `--SEMI -> ; [47:66]
        |       |   |--CASE_GROUP -> CASE_GROUP [49:13]
        |       |   |   |--LITERAL_CASE -> case [49:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [49:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [49:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [49:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [49:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [49:18]
        |       |   |   |   |       |   `--IDENT -> i1 [49:26]
        |       |   |   |   |       `--EXPR -> EXPR [49:44]
        |       |   |   |   |           `--EQUAL -> == [49:44]
        |       |   |   |   |               |--LPAREN -> ( [49:34]
        |       |   |   |   |               |--BAND -> & [49:39]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [49:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [49:36]
        |       |   |   |   |               |   `--NUM_INT -> 0 [49:41]
        |       |   |   |   |               |--RPAREN -> ) [49:42]
        |       |   |   |   |               `--NUM_INT -> 0 [49:47]
        |       |   |   |   `--COLON -> : [49:48]
        |       |   |   `--SLIST -> SLIST [49:52]
        |       |   |       |--EXPR -> EXPR [49:52]
        |       |   |       |   `--METHOD_CALL -> ( [49:52]
        |       |   |       |       |--IDENT -> m2 [49:50]
        |       |   |       |       |--ELIST -> ELIST [49:53]
        |       |   |       |       |   `--EXPR -> EXPR [49:53]
        |       |   |       |       |       `--IDENT -> i1 [49:53]
        |       |   |       |       `--RPAREN -> ) [49:55]
        |       |   |       |--SEMI -> ; [49:56]
        |       |   |       `--LITERAL_BREAK -> break [49:58]
        |       |   |           `--SEMI -> ; [49:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [50:13]
        |       |   |   |--LITERAL_CASE -> case [50:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [50:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [50:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [50:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [50:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [50:18]
        |       |   |   |   |       |   `--IDENT -> i1 [50:26]
        |       |   |   |   |       `--EXPR -> EXPR [50:44]
        |       |   |   |   |           `--EQUAL -> == [50:44]
        |       |   |   |   |               |--LPAREN -> ( [50:34]
        |       |   |   |   |               |--BOR -> | [50:39]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [50:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [50:36]
        |       |   |   |   |               |   `--NUM_INT -> 0 [50:41]
        |       |   |   |   |               |--RPAREN -> ) [50:42]
        |       |   |   |   |               `--NUM_INT -> 0 [50:47]
        |       |   |   |   `--COLON -> : [50:48]
        |       |   |   `--SLIST -> SLIST [50:52]
        |       |   |       |--EXPR -> EXPR [50:52]
        |       |   |       |   `--METHOD_CALL -> ( [50:52]
        |       |   |       |       |--IDENT -> m2 [50:50]
        |       |   |       |       |--ELIST -> ELIST [50:53]
        |       |   |       |       |   `--EXPR -> EXPR [50:53]
        |       |   |       |       |       `--IDENT -> i1 [50:53]
        |       |   |       |       `--RPAREN -> ) [50:55]
        |       |   |       |--SEMI -> ; [50:56]
        |       |   |       `--LITERAL_BREAK -> break [50:58]
        |       |   |           `--SEMI -> ; [50:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [51:13]
        |       |   |   |--LITERAL_CASE -> case [51:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [51:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [51:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [51:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [51:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [51:18]
        |       |   |   |   |       |   `--IDENT -> i1 [51:26]
        |       |   |   |   |       `--EXPR -> EXPR [51:39]
        |       |   |   |   |           `--EQUAL -> == [51:39]
        |       |   |   |   |               |--BNOT -> ~ [51:34]
        |       |   |   |   |               |   `--UNARY_MINUS -> - [51:35]
        |       |   |   |   |               |       `--IDENT -> i1 [51:36]
        |       |   |   |   |               `--NUM_INT -> 0 [51:42]
        |       |   |   |   `--COLON -> : [51:43]
        |       |   |   `--SLIST -> SLIST [51:47]
        |       |   |       |--EXPR -> EXPR [51:47]
        |       |   |       |   `--METHOD_CALL -> ( [51:47]
        |       |   |       |       |--IDENT -> m2 [51:45]
        |       |   |       |       |--ELIST -> ELIST [51:48]
        |       |   |       |       |   `--EXPR -> EXPR [51:48]
        |       |   |       |       |       `--IDENT -> i1 [51:48]
        |       |   |       |       `--RPAREN -> ) [51:50]
        |       |   |       |--SEMI -> ; [51:51]
        |       |   |       `--LITERAL_BREAK -> break [51:53]
        |       |   |           `--SEMI -> ; [51:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [52:13]
        |       |   |   |--LITERAL_CASE -> case [52:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [52:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [52:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [52:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [52:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [52:18]
        |       |   |   |   |       |   `--IDENT -> i1 [52:26]
        |       |   |   |   |       `--EXPR -> EXPR [52:43]
        |       |   |   |   |           `--EQUAL -> == [52:43]
        |       |   |   |   |               |--SL -> << [52:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [52:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [52:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [52:41]
        |       |   |   |   |               `--NUM_INT -> 0 [52:46]
        |       |   |   |   `--COLON -> : [52:47]
        |       |   |   `--SLIST -> SLIST [52:51]
        |       |   |       |--EXPR -> EXPR [52:51]
        |       |   |       |   `--METHOD_CALL -> ( [52:51]
        |       |   |       |       |--IDENT -> m2 [52:49]
        |       |   |       |       |--ELIST -> ELIST [52:52]
        |       |   |       |       |   `--EXPR -> EXPR [52:52]
        |       |   |       |       |       `--IDENT -> i1 [52:52]
        |       |   |       |       `--RPAREN -> ) [52:54]
        |       |   |       |--SEMI -> ; [52:55]
        |       |   |       `--LITERAL_BREAK -> break [52:57]
        |       |   |           `--SEMI -> ; [52:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [53:13]
        |       |   |   |--LITERAL_CASE -> case [53:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [53:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [53:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [53:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [53:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [53:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [53:18]
        |       |   |   |   |       |   `--IDENT -> i1 [53:26]
        |       |   |   |   |       `--EXPR -> EXPR [53:43]
        |       |   |   |   |           `--EQUAL -> == [53:43]
        |       |   |   |   |               |--SR -> >> [53:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [53:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [53:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [53:41]
        |       |   |   |   |               `--NUM_INT -> 0 [53:46]
        |       |   |   |   `--COLON -> : [53:47]
        |       |   |   `--SLIST -> SLIST [53:51]
        |       |   |       |--EXPR -> EXPR [53:51]
        |       |   |       |   `--METHOD_CALL -> ( [53:51]
        |       |   |       |       |--IDENT -> m2 [53:49]
        |       |   |       |       |--ELIST -> ELIST [53:52]
        |       |   |       |       |   `--EXPR -> EXPR [53:52]
        |       |   |       |       |       `--IDENT -> i1 [53:52]
        |       |   |       |       `--RPAREN -> ) [53:54]
        |       |   |       |--SEMI -> ; [53:55]
        |       |   |       `--LITERAL_BREAK -> break [53:57]
        |       |   |           `--SEMI -> ; [53:62]
        |       |   |--CASE_GROUP -> CASE_GROUP [54:13]
        |       |   |   |--LITERAL_CASE -> case [54:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [54:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [54:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [54:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [54:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [54:18]
        |       |   |   |   |       |   `--IDENT -> i1 [54:26]
        |       |   |   |   |       `--EXPR -> EXPR [54:44]
        |       |   |   |   |           `--EQUAL -> == [54:44]
        |       |   |   |   |               |--BSR -> >>> [54:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [54:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [54:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [54:42]
        |       |   |   |   |               `--NUM_INT -> 0 [54:47]
        |       |   |   |   `--COLON -> : [54:48]
        |       |   |   `--SLIST -> SLIST [54:52]
        |       |   |       |--EXPR -> EXPR [54:52]
        |       |   |       |   `--METHOD_CALL -> ( [54:52]
        |       |   |       |       |--IDENT -> m2 [54:50]
        |       |   |       |       |--ELIST -> ELIST [54:53]
        |       |   |       |       |   `--EXPR -> EXPR [54:53]
        |       |   |       |       |       `--IDENT -> i1 [54:53]
        |       |   |       |       `--RPAREN -> ) [54:55]
        |       |   |       |--SEMI -> ; [54:56]
        |       |   |       `--LITERAL_BREAK -> break [54:58]
        |       |   |           `--SEMI -> ; [54:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [55:13]
        |       |   |   |--LITERAL_CASE -> case [55:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [55:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [55:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [55:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [55:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [55:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [55:18]
        |       |   |   |   |       |   `--IDENT -> i1 [55:26]
        |       |   |   |   |       `--EXPR -> EXPR [55:44]
        |       |   |   |   |           `--EQUAL -> == [55:44]
        |       |   |   |   |               |--LPAREN -> ( [55:34]
        |       |   |   |   |               |--BXOR -> ^ [55:39]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [55:35]
        |       |   |   |   |               |   |   `--IDENT -> i1 [55:36]
        |       |   |   |   |               |   `--NUM_INT -> 2 [55:41]
        |       |   |   |   |               |--RPAREN -> ) [55:42]
        |       |   |   |   |               `--NUM_INT -> 0 [55:47]
        |       |   |   |   `--COLON -> : [55:48]
        |       |   |   `--SLIST -> SLIST [55:52]
        |       |   |       |--EXPR -> EXPR [55:52]
        |       |   |       |   `--METHOD_CALL -> ( [55:52]
        |       |   |       |       |--IDENT -> m2 [55:50]
        |       |   |       |       |--ELIST -> ELIST [55:53]
        |       |   |       |       |   `--EXPR -> EXPR [55:53]
        |       |   |       |       |       `--IDENT -> i1 [55:53]
        |       |   |       |       `--RPAREN -> ) [55:55]
        |       |   |       |--SEMI -> ; [55:56]
        |       |   |       `--LITERAL_BREAK -> break [55:58]
        |       |   |           `--SEMI -> ; [55:63]
        |       |   |--CASE_GROUP -> CASE_GROUP [56:13]
        |       |   |   |--LITERAL_CASE -> case [56:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [56:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [56:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [56:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [56:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [56:18]
        |       |   |   |   |       |   `--IDENT -> i1 [56:26]
        |       |   |   |   |       `--EXPR -> EXPR [56:37]
        |       |   |   |   |           `--LITERAL_INSTANCEOF -> instanceof [56:37]
        |       |   |   |   |               |--IDENT -> i1 [56:34]
        |       |   |   |   |               `--TYPE -> TYPE [56:48]
        |       |   |   |   |                   `--IDENT -> Number [56:48]
        |       |   |   |   `--COLON -> : [56:54]
        |       |   |   `--SLIST -> SLIST [56:58]
        |       |   |       |--EXPR -> EXPR [56:58]
        |       |   |       |   `--METHOD_CALL -> ( [56:58]
        |       |   |       |       |--IDENT -> m2 [56:56]
        |       |   |       |       |--ELIST -> ELIST [56:59]
        |       |   |       |       |   `--EXPR -> EXPR [56:59]
        |       |   |       |       |       `--IDENT -> i1 [56:59]
        |       |   |       |       `--RPAREN -> ) [56:61]
        |       |   |       |--SEMI -> ; [56:62]
        |       |   |       `--LITERAL_BREAK -> break [56:64]
        |       |   |           `--SEMI -> ; [56:69]
        |       |   |--CASE_GROUP -> CASE_GROUP [57:13]
        |       |   |   |--LITERAL_CASE -> case [57:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [57:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [57:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [57:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [57:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [57:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [57:18]
        |       |   |   |   |       |   `--IDENT -> i1 [57:26]
        |       |   |   |   |       `--EXPR -> EXPR [57:40]
        |       |   |   |   |           `--EQUAL -> == [57:40]
        |       |   |   |   |               |--UNARY_MINUS -> - [57:34]
        |       |   |   |   |               |   `--POST_DEC -> -- [57:37]
        |       |   |   |   |               |       `--IDENT -> i1 [57:35]
        |       |   |   |   |               `--NUM_INT -> 0 [57:43]
        |       |   |   |   `--COLON -> : [57:44]
        |       |   |   `--SLIST -> SLIST [57:48]
        |       |   |       |--EXPR -> EXPR [57:48]
        |       |   |       |   `--METHOD_CALL -> ( [57:48]
        |       |   |       |       |--IDENT -> m2 [57:46]
        |       |   |       |       |--ELIST -> ELIST [57:49]
        |       |   |       |       |   `--EXPR -> EXPR [57:49]
        |       |   |       |       |       `--IDENT -> i1 [57:49]
        |       |   |       |       `--RPAREN -> ) [57:51]
        |       |   |       |--SEMI -> ; [57:52]
        |       |   |       `--LITERAL_BREAK -> break [57:54]
        |       |   |           `--SEMI -> ; [57:59]
        |       |   |--CASE_GROUP -> CASE_GROUP [58:13]
        |       |   |   |--LITERAL_CASE -> case [58:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [58:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [58:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [58:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [58:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [58:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [58:18]
        |       |   |   |   |       |   `--IDENT -> i1 [58:26]
        |       |   |   |   |       `--EXPR -> EXPR [58:39]
        |       |   |   |   |           `--EQUAL -> == [58:39]
        |       |   |   |   |               |--POST_INC -> ++ [58:36]
        |       |   |   |   |               |   `--IDENT -> i1 [58:34]
        |       |   |   |   |               `--NUM_INT -> 0 [58:42]
        |       |   |   |   `--COLON -> : [58:43]
        |       |   |   `--SLIST -> SLIST [58:47]
        |       |   |       |--EXPR -> EXPR [58:47]
        |       |   |       |   `--METHOD_CALL -> ( [58:47]
        |       |   |       |       |--IDENT -> m2 [58:45]
        |       |   |       |       |--ELIST -> ELIST [58:48]
        |       |   |       |       |   `--EXPR -> EXPR [58:48]
        |       |   |       |       |       `--IDENT -> i1 [58:48]
        |       |   |       |       `--RPAREN -> ) [58:50]
        |       |   |       |--SEMI -> ; [58:51]
        |       |   |       `--LITERAL_BREAK -> break [58:53]
        |       |   |           `--SEMI -> ; [58:58]
        |       |   |--CASE_GROUP -> CASE_GROUP [59:13]
        |       |   |   |--LITERAL_CASE -> case [59:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [59:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [59:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [59:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [59:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [59:18]
        |       |   |   |   |       |   `--IDENT -> i1 [59:26]
        |       |   |   |   |       `--EXPR -> EXPR [59:41]
        |       |   |   |   |           `--EQUAL -> == [59:41]
        |       |   |   |   |               |--PLUS -> + [59:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [59:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [59:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [59:40]
        |       |   |   |   |               `--NUM_INT -> 0 [59:44]
        |       |   |   |   `--COLON -> : [59:45]
        |       |   |   `--SLIST -> SLIST [59:49]
        |       |   |       |--EXPR -> EXPR [59:49]
        |       |   |       |   `--METHOD_CALL -> ( [59:49]
        |       |   |       |       |--IDENT -> m2 [59:47]
        |       |   |       |       |--ELIST -> ELIST [59:50]
        |       |   |       |       |   `--EXPR -> EXPR [59:50]
        |       |   |       |       |       `--IDENT -> i1 [59:50]
        |       |   |       |       `--RPAREN -> ) [59:52]
        |       |   |       |--SEMI -> ; [59:53]
        |       |   |       `--LITERAL_BREAK -> break [59:55]
        |       |   |           `--SEMI -> ; [59:60]
        |       |   |--CASE_GROUP -> CASE_GROUP [60:13]
        |       |   |   |--LITERAL_CASE -> case [60:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [60:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [60:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [60:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [60:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [60:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [60:18]
        |       |   |   |   |       |   `--IDENT -> i1 [60:26]
        |       |   |   |   |       `--EXPR -> EXPR [60:42]
        |       |   |   |   |           `--EQUAL -> == [60:42]
        |       |   |   |   |               |--MINUS -> - [60:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [60:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [60:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [60:40]
        |       |   |   |   |               `--NUM_INT -> 0 [60:45]
        |       |   |   |   `--COLON -> : [60:46]
        |       |   |   `--SLIST -> SLIST [60:50]
        |       |   |       |--EXPR -> EXPR [60:50]
        |       |   |       |   `--METHOD_CALL -> ( [60:50]
        |       |   |       |       |--IDENT -> m2 [60:48]
        |       |   |       |       |--ELIST -> ELIST [60:51]
        |       |   |       |       |   `--EXPR -> EXPR [60:51]
        |       |   |       |       |       `--IDENT -> i1 [60:51]
        |       |   |       |       `--RPAREN -> ) [60:53]
        |       |   |       |--SEMI -> ; [60:54]
        |       |   |       `--LITERAL_BREAK -> break [60:56]
        |       |   |           `--SEMI -> ; [60:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [61:13]
        |       |   |   |--LITERAL_CASE -> case [61:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [61:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [61:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [61:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [61:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [61:18]
        |       |   |   |   |       |   `--IDENT -> i1 [61:26]
        |       |   |   |   |       `--EXPR -> EXPR [61:42]
        |       |   |   |   |           `--EQUAL -> == [61:42]
        |       |   |   |   |               |--DIV -> / [61:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [61:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [61:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [61:40]
        |       |   |   |   |               `--NUM_INT -> 0 [61:45]
        |       |   |   |   `--COLON -> : [61:46]
        |       |   |   `--SLIST -> SLIST [61:50]
        |       |   |       |--EXPR -> EXPR [61:50]
        |       |   |       |   `--METHOD_CALL -> ( [61:50]
        |       |   |       |       |--IDENT -> m2 [61:48]
        |       |   |       |       |--ELIST -> ELIST [61:51]
        |       |   |       |       |   `--EXPR -> EXPR [61:51]
        |       |   |       |       |       `--IDENT -> i1 [61:51]
        |       |   |       |       `--RPAREN -> ) [61:53]
        |       |   |       |--SEMI -> ; [61:54]
        |       |   |       `--LITERAL_BREAK -> break [61:56]
        |       |   |           `--SEMI -> ; [61:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [62:13]
        |       |   |   |--LITERAL_CASE -> case [62:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [62:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [62:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [62:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [62:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [62:18]
        |       |   |   |   |       |   `--IDENT -> i1 [62:26]
        |       |   |   |   |       `--EXPR -> EXPR [62:42]
        |       |   |   |   |           `--EQUAL -> == [62:42]
        |       |   |   |   |               |--STAR -> * [62:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [62:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [62:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [62:40]
        |       |   |   |   |               `--NUM_INT -> 0 [62:45]
        |       |   |   |   `--COLON -> : [62:46]
        |       |   |   `--SLIST -> SLIST [62:50]
        |       |   |       |--EXPR -> EXPR [62:50]
        |       |   |       |   `--METHOD_CALL -> ( [62:50]
        |       |   |       |       |--IDENT -> m2 [62:48]
        |       |   |       |       |--ELIST -> ELIST [62:51]
        |       |   |       |       |   `--EXPR -> EXPR [62:51]
        |       |   |       |       |       `--IDENT -> i1 [62:51]
        |       |   |       |       `--RPAREN -> ) [62:53]
        |       |   |       |--SEMI -> ; [62:54]
        |       |   |       `--LITERAL_BREAK -> break [62:56]
        |       |   |           `--SEMI -> ; [62:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [63:13]
        |       |   |   |--LITERAL_CASE -> case [63:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [63:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [63:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [63:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [63:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [63:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [63:18]
        |       |   |   |   |       |   `--IDENT -> i1 [63:26]
        |       |   |   |   |       `--EXPR -> EXPR [63:42]
        |       |   |   |   |           `--EQUAL -> == [63:42]
        |       |   |   |   |               |--MOD -> % [63:38]
        |       |   |   |   |               |   |--UNARY_MINUS -> - [63:34]
        |       |   |   |   |               |   |   `--IDENT -> i1 [63:35]
        |       |   |   |   |               |   `--NUM_INT -> 2 [63:40]
        |       |   |   |   |               `--NUM_INT -> 0 [63:45]
        |       |   |   |   `--COLON -> : [63:46]
        |       |   |   `--SLIST -> SLIST [63:50]
        |       |   |       |--EXPR -> EXPR [63:50]
        |       |   |       |   `--METHOD_CALL -> ( [63:50]
        |       |   |       |       |--IDENT -> m2 [63:48]
        |       |   |       |       |--ELIST -> ELIST [63:51]
        |       |   |       |       |   `--EXPR -> EXPR [63:51]
        |       |   |       |       |       `--IDENT -> i1 [63:51]
        |       |   |       |       `--RPAREN -> ) [63:53]
        |       |   |       |--SEMI -> ; [63:54]
        |       |   |       `--LITERAL_BREAK -> break [63:56]
        |       |   |           `--SEMI -> ; [63:61]
        |       |   |--CASE_GROUP -> CASE_GROUP [64:13]
        |       |   |   |--LITERAL_CASE -> case [64:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [64:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [64:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [64:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [64:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [64:18]
        |       |   |   |   |       |   |   `--IDENT -> Integer [64:18]
        |       |   |   |   |       |   `--IDENT -> i1 [64:26]
        |       |   |   |   |       `--EXPR -> EXPR [64:47]
        |       |   |   |   |           `--EQUAL -> == [64:47]
        |       |   |   |   |               |--MOD -> % [64:43]
        |       |   |   |   |               |   |--TYPECAST -> ( [64:34]
        |       |   |   |   |               |   |   |--TYPE -> TYPE [64:35]
        |       |   |   |   |               |   |   |   `--LITERAL_INT -> int [64:35]
        |       |   |   |   |               |   |   |--RPAREN -> ) [64:38]
        |       |   |   |   |               |   |   `--UNARY_MINUS -> - [64:39]
        |       |   |   |   |               |   |       `--IDENT -> i1 [64:40]
        |       |   |   |   |               |   `--NUM_INT -> 2 [64:45]
        |       |   |   |   |               `--NUM_INT -> 0 [64:50]
        |       |   |   |   `--COLON -> : [64:51]
        |       |   |   `--SLIST -> SLIST [64:55]
        |       |   |       |--EXPR -> EXPR [64:55]
        |       |   |       |   `--METHOD_CALL -> ( [64:55]
        |       |   |       |       |--IDENT -> m2 [64:53]
        |       |   |       |       |--ELIST -> ELIST [64:56]
        |       |   |       |       |   `--EXPR -> EXPR [64:56]
        |       |   |       |       |       `--IDENT -> i1 [64:56]
        |       |   |       |       `--RPAREN -> ) [64:58]
        |       |   |       |--SEMI -> ; [64:59]
        |       |   |       `--LITERAL_BREAK -> break [64:61]
        |       |   |           `--SEMI -> ; [64:66]
        |       |   |--CASE_GROUP -> CASE_GROUP [66:13]
        |       |   |   |--LITERAL_CASE -> case [66:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [66:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [66:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [66:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [66:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [66:18]
        |       |   |   |   |       |   |   `--IDENT -> Boolean [66:18]
        |       |   |   |   |       |   `--IDENT -> b1 [66:26]
        |       |   |   |   |       `--EXPR -> EXPR [66:37]
        |       |   |   |   |           `--LOR -> || [66:37]
        |       |   |   |   |               |--IDENT -> b1 [66:34]
        |       |   |   |   |               `--LNOT -> ! [66:40]
        |       |   |   |   |                   `--IDENT -> b1 [66:41]
        |       |   |   |   `--COLON -> : [66:43]
        |       |   |   `--SLIST -> SLIST [66:47]
        |       |   |       |--EXPR -> EXPR [66:47]
        |       |   |       |   `--METHOD_CALL -> ( [66:47]
        |       |   |       |       |--IDENT -> m2 [66:45]
        |       |   |       |       |--ELIST -> ELIST [66:48]
        |       |   |       |       |   `--EXPR -> EXPR [66:48]
        |       |   |       |       |       `--NUM_INT -> 2 [66:48]
        |       |   |       |       `--RPAREN -> ) [66:49]
        |       |   |       |--SEMI -> ; [66:50]
        |       |   |       `--LITERAL_BREAK -> break [66:52]
        |       |   |           `--SEMI -> ; [66:57]
        |       |   |--CASE_GROUP -> CASE_GROUP [67:13]
        |       |   |   |--LITERAL_CASE -> case [67:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [67:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [67:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [67:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [67:18]
        |       |   |   |   |       |   |   `--IDENT -> Boolean [67:18]
        |       |   |   |   |       |   `--IDENT -> b1 [67:26]
        |       |   |   |   |       `--EXPR -> EXPR [67:37]
        |       |   |   |   |           `--LAND -> && [67:37]
        |       |   |   |   |               |--IDENT -> b1 [67:34]
        |       |   |   |   |               `--LNOT -> ! [67:40]
        |       |   |   |   |                   `--IDENT -> b1 [67:41]
        |       |   |   |   `--COLON -> : [67:43]
        |       |   |   `--SLIST -> SLIST [67:47]
        |       |   |       |--EXPR -> EXPR [67:47]
        |       |   |       |   `--METHOD_CALL -> ( [67:47]
        |       |   |       |       |--IDENT -> m2 [67:45]
        |       |   |       |       |--ELIST -> ELIST [67:48]
        |       |   |       |       |   `--EXPR -> EXPR [67:48]
        |       |   |       |       |       `--NUM_INT -> 2 [67:48]
        |       |   |       |       `--RPAREN -> ) [67:49]
        |       |   |       |--SEMI -> ; [67:50]
        |       |   |       `--LITERAL_BREAK -> break [67:52]
        |       |   |           `--SEMI -> ; [67:57]
        |       |   |--CASE_GROUP -> CASE_GROUP [68:13]
        |       |   |   |--LITERAL_CASE -> case [68:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [68:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [68:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [68:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [68:18]
        |       |   |   |   |       |   |   `--IDENT -> Boolean [68:18]
        |       |   |   |   |       |   `--IDENT -> b1 [68:26]
        |       |   |   |   |       `--EXPR -> EXPR [68:34]
        |       |   |   |   |           `--LNOT -> ! [68:34]
        |       |   |   |   |               `--IDENT -> b1 [68:35]
        |       |   |   |   `--COLON -> : [68:37]
        |       |   |   `--SLIST -> SLIST [68:41]
        |       |   |       |--EXPR -> EXPR [68:41]
        |       |   |       |   `--METHOD_CALL -> ( [68:41]
        |       |   |       |       |--IDENT -> m2 [68:39]
        |       |   |       |       |--ELIST -> ELIST [68:42]
        |       |   |       |       |   `--EXPR -> EXPR [68:42]
        |       |   |       |       |       `--NUM_INT -> 2 [68:42]
        |       |   |       |       `--RPAREN -> ) [68:43]
        |       |   |       |--SEMI -> ; [68:44]
        |       |   |       `--LITERAL_BREAK -> break [68:46]
        |       |   |           `--SEMI -> ; [68:51]
        |       |   |--CASE_GROUP -> CASE_GROUP [69:13]
        |       |   |   |--LITERAL_CASE -> case [69:13]
        |       |   |   |   |--PATTERN_DEF -> PATTERN_DEF [69:29]
        |       |   |   |   |   `--LITERAL_WHEN -> when [69:29]
        |       |   |   |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [69:18]
        |       |   |   |   |       |   |--MODIFIERS -> MODIFIERS [69:18]
        |       |   |   |   |       |   |--TYPE -> TYPE [69:18]
        |       |   |   |   |       |   |   `--IDENT -> Boolean [69:18]
        |       |   |   |   |       |   `--IDENT -> b1 [69:26]
        |       |   |   |   |       `--EXPR -> EXPR [69:36]
        |       |   |   |   |           `--QUESTION -> ? [69:36]
        |       |   |   |   |               |--IDENT -> b1 [69:34]
        |       |   |   |   |               |--LITERAL_TRUE -> true [69:38]
        |       |   |   |   |               |--COLON -> : [69:42]
        |       |   |   |   |               `--LITERAL_FALSE -> false [69:44]
        |       |   |   |   `--COLON -> : [69:49]
        |       |   |   `--SLIST -> SLIST [69:53]
        |       |   |       |--EXPR -> EXPR [69:53]
        |       |   |       |   `--METHOD_CALL -> ( [69:53]
        |       |   |       |       |--IDENT -> m3 [69:51]
        |       |   |       |       |--ELIST -> ELIST [69:66]
        |       |   |       |       |   `--EXPR -> EXPR [69:66]
        |       |   |       |       |       `--METHOD_CALL -> ( [69:66]
        |       |   |       |       |           |--DOT -> . [69:56]
        |       |   |       |       |           |   |--IDENT -> b1 [69:54]
        |       |   |       |       |           |   `--IDENT -> compareTo [69:57]
        |       |   |       |       |           |--ELIST -> ELIST [69:67]
        |       |   |       |       |           |   `--EXPR -> EXPR [69:67]
        |       |   |       |       |           |       `--LITERAL_FALSE -> false [69:67]
        |       |   |       |       |           `--RPAREN -> ) [69:72]
        |       |   |       |       `--RPAREN -> ) [69:73]
        |       |   |       |--SEMI -> ; [69:74]
        |       |   |       `--LITERAL_BREAK -> break [69:76]
        |       |   |           `--SEMI -> ; [69:81]
        |       |   |--CASE_GROUP -> CASE_GROUP [71:13]
        |       |   |   |--LITERAL_CASE -> case [71:13]
        |       |   |   |   |--EXPR -> EXPR [71:18]
        |       |   |   |   |   `--LITERAL_NULL -> null [71:18]
        |       |   |   |   |--COMMA -> , [71:22]
        |       |   |   |   |--LITERAL_DEFAULT -> default [71:24]
        |       |   |   |   `--COLON -> : [71:31]
        |       |   |   `--SLIST -> SLIST [71:35]
        |       |   |       |--EXPR -> EXPR [71:35]
        |       |   |       |   `--METHOD_CALL -> ( [71:35]
        |       |   |       |       |--IDENT -> m2 [71:33]
        |       |   |       |       |--ELIST -> ELIST [71:36]
        |       |   |       |       |   `--EXPR -> EXPR [71:36]
        |       |   |       |       |       `--NUM_INT -> 42 [71:36]
        |       |   |       |       `--RPAREN -> ) [71:38]
        |       |   |       `--SEMI -> ; [71:39]
        |       |   `--RCURLY -> } [72:9]
        |       `--RCURLY -> } [73:5]
        |--METHOD_DEF -> METHOD_DEF [75:5]
        |   |--MODIFIERS -> MODIFIERS [75:5]
        |   |--TYPE -> TYPE [75:5]
        |   |   `--LITERAL_VOID -> void [75:5]
        |   |--IDENT -> m2 [75:10]
        |   |--LPAREN -> ( [75:12]
        |   |--PARAMETERS -> PARAMETERS [75:13]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [75:13]
        |   |       |--MODIFIERS -> MODIFIERS [75:13]
        |   |       |--TYPE -> TYPE [75:13]
        |   |       |   `--LITERAL_INT -> int [75:13]
        |   |       `--IDENT -> x [75:17]
        |   |--RPAREN -> ) [75:18]
        |   `--SLIST -> { [75:20]
        |       |--EXPR -> EXPR [75:40]
        |       |   `--METHOD_CALL -> ( [75:40]
        |       |       |--DOT -> . [75:32]
        |       |       |   |--DOT -> . [75:28]
        |       |       |   |   |--IDENT -> System [75:22]
        |       |       |   |   `--IDENT -> out [75:29]
        |       |       |   `--IDENT -> println [75:33]
        |       |       |--ELIST -> ELIST [75:41]
        |       |       |   `--EXPR -> EXPR [75:41]
        |       |       |       `--IDENT -> x [75:41]
        |       |       `--RPAREN -> ) [75:42]
        |       |--SEMI -> ; [75:43]
        |       `--RCURLY -> } [75:45]
        |--METHOD_DEF -> METHOD_DEF [76:5]
        |   |--MODIFIERS -> MODIFIERS [76:5]
        |   |--TYPE -> TYPE [76:5]
        |   |   `--LITERAL_BOOLEAN -> boolean [76:5]
        |   |--IDENT -> m3 [76:13]
        |   |--LPAREN -> ( [76:15]
        |   |--PARAMETERS -> PARAMETERS [76:16]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [76:16]
        |   |       |--MODIFIERS -> MODIFIERS [76:16]
        |   |       |--TYPE -> TYPE [76:16]
        |   |       |   `--LITERAL_INT -> int [76:16]
        |   |       `--IDENT -> x [76:20]
        |   |--RPAREN -> ) [76:21]
        |   `--SLIST -> { [76:22]
        |       |--LITERAL_RETURN -> return [76:24]
        |       |   |--EXPR -> EXPR [76:31]
        |       |   |   `--LITERAL_TRUE -> true [76:31]
        |       |   `--SEMI -> ; [76:35]
        |       `--RCURLY -> } [76:37]
        `--RCURLY -> } [77:1]
