COMPILATION_UNIT -> COMPILATION_UNIT [3:1]
|--PACKAGE_DEF -> package [3:1]
|   |--ANNOTATIONS -> ANNOTATIONS [3:48]
|   |--DOT -> . [3:48]
|   |   |--DOT -> . [3:40]
|   |   |   |--DOT -> . [3:29]
|   |   |   |   |--DOT -> . [3:23]
|   |   |   |   |   |--DOT -> . [3:12]
|   |   |   |   |   |   |--IDENT -> com [3:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [3:13]
|   |   |   |   |   `--IDENT -> tools [3:24]
|   |   |   |   `--IDENT -> checkstyle [3:30]
|   |   |   `--IDENT -> grammar [3:41]
|   |   `--IDENT -> java14 [3:49]
|   `--SEMI -> ; [3:55]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--STAR -> * [4:18]
|   `--SEMI -> ; [4:19]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:17]
|   |   |--DOT -> . [5:12]
|   |   |   |--IDENT -> java [5:8]
|   |   |   `--IDENT -> util [5:13]
|   |   `--IDENT -> Arrays [5:18]
|   `--SEMI -> ; [5:24]
|--IMPORT -> import [6:1]
|   |--DOT -> . [6:17]
|   |   |--DOT -> . [6:12]
|   |   |   |--IDENT -> java [6:8]
|   |   |   `--IDENT -> util [6:13]
|   |   `--IDENT -> Locale [6:18]
|   `--SEMI -> ; [6:24]
`--CLASS_DEF -> CLASS_DEF [11:1]
    |--MODIFIERS -> MODIFIERS [11:1]
    |   `--LITERAL_PUBLIC -> public [11:1]
    |--LITERAL_CLASS -> class [11:8]
    |--IDENT -> InputJava14InstanceofWithPatternMatching [11:14]
    `--OBJBLOCK -> OBJBLOCK [11:55]
        |--LCURLY -> { [11:55]
        |--CLASS_DEF -> CLASS_DEF [13:5]
        |   |--MODIFIERS -> MODIFIERS [13:5]
        |   |   `--LITERAL_PUBLIC -> public [13:5]
        |   |--LITERAL_CLASS -> class [13:12]
        |   |--IDENT -> Keyboard [13:18]
        |   `--OBJBLOCK -> OBJBLOCK [13:27]
        |       |--LCURLY -> { [13:27]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [14:9]
        |       |   |--MODIFIERS -> MODIFIERS [14:9]
        |       |   |   `--LITERAL_PRIVATE -> private [14:9]
        |       |   |--TYPE -> TYPE [14:17]
        |       |   |   `--IDENT -> String [14:17]
        |       |   |--IDENT -> model [14:24]
        |       |   |--ASSIGN -> = [14:30]
        |       |   |   `--EXPR -> EXPR [14:32]
        |       |   |       `--LITERAL_NULL -> null [14:32]
        |       |   `--SEMI -> ; [14:36]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [15:9]
        |       |   |--MODIFIERS -> MODIFIERS [15:9]
        |       |   |   |--LITERAL_PRIVATE -> private [15:9]
        |       |   |   `--FINAL -> final [15:17]
        |       |   |--TYPE -> TYPE [15:23]
        |       |   |   `--LITERAL_INT -> int [15:23]
        |       |   |--IDENT -> price [15:27]
        |       |   `--SEMI -> ; [15:32]
        |       |--CTOR_DEF -> CTOR_DEF [17:9]
        |       |   |--MODIFIERS -> MODIFIERS [17:9]
        |       |   |   `--LITERAL_PUBLIC -> public [17:9]
        |       |   |--IDENT -> Keyboard [17:16]
        |       |   |--LPAREN -> ( [17:24]
        |       |   |--PARAMETERS -> PARAMETERS [17:25]
        |       |   |--RPAREN -> ) [17:25]
        |       |   `--SLIST -> { [17:27]
        |       |       |--EXPR -> EXPR [18:19]
        |       |       |   `--ASSIGN -> = [18:19]
        |       |       |       |--IDENT -> price [18:13]
        |       |       |       `--NUM_INT -> 0 [18:21]
        |       |       |--SEMI -> ; [18:22]
        |       |       `--RCURLY -> } [19:9]
        |       |--METHOD_DEF -> METHOD_DEF [22:9]
        |       |   |--MODIFIERS -> MODIFIERS [22:9]
        |       |   |   |--ANNOTATION -> ANNOTATION [22:9]
        |       |   |   |   |--AT -> @ [22:9]
        |       |   |   |   `--IDENT -> Override [22:10]
        |       |   |   `--LITERAL_PUBLIC -> public [23:9]
        |       |   |--TYPE -> TYPE [23:16]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [23:16]
        |       |   |--IDENT -> equals [23:24]
        |       |   |--LPAREN -> ( [23:30]
        |       |   |--PARAMETERS -> PARAMETERS [23:31]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [23:31]
        |       |   |       |--MODIFIERS -> MODIFIERS [23:31]
        |       |   |       |--TYPE -> TYPE [23:31]
        |       |   |       |   `--IDENT -> Object [23:31]
        |       |   |       `--IDENT -> obj [23:38]
        |       |   |--RPAREN -> ) [23:41]
        |       |   `--SLIST -> { [23:43]
        |       |       |--LITERAL_RETURN -> return [24:13]
        |       |       |   |--EXPR -> EXPR [25:47]
        |       |       |   |   `--LAND -> && [25:47]
        |       |       |   |       |--LAND -> && [24:50]
        |       |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [24:24]
        |       |       |   |       |   |   |--IDENT -> obj [24:20]
        |       |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:35]
        |       |       |   |       |   |       |--MODIFIERS -> MODIFIERS [24:35]
        |       |       |   |       |   |       |--TYPE -> TYPE [24:35]
        |       |       |   |       |   |       |   `--IDENT -> Keyboard [24:35]
        |       |       |   |       |   |       `--IDENT -> other [24:44]
        |       |       |   |       |   `--METHOD_CALL -> ( [25:33]
        |       |       |   |       |       |--DOT -> . [25:26]
        |       |       |   |       |       |   |--IDENT -> model [25:21]
        |       |       |   |       |       |   `--IDENT -> equals [25:27]
        |       |       |   |       |       |--ELIST -> ELIST [25:39]
        |       |       |   |       |       |   `--EXPR -> EXPR [25:39]
        |       |       |   |       |       |       `--DOT -> . [25:39]
        |       |       |   |       |       |           |--IDENT -> other [25:34]
        |       |       |   |       |       |           `--IDENT -> model [25:40]
        |       |       |   |       |       `--RPAREN -> ) [25:45]
        |       |       |   |       `--EQUAL -> == [26:27]
        |       |       |   |           |--IDENT -> price [26:21]
        |       |       |   |           `--DOT -> . [26:35]
        |       |       |   |               |--IDENT -> other [26:30]
        |       |       |   |               `--IDENT -> price [26:36]
        |       |       |   `--SEMI -> ; [26:41]
        |       |       `--RCURLY -> } [27:9]
        |       |--METHOD_DEF -> METHOD_DEF [29:9]
        |       |   |--MODIFIERS -> MODIFIERS [29:9]
        |       |   |   `--LITERAL_PUBLIC -> public [29:9]
        |       |   |--TYPE -> TYPE [29:16]
        |       |   |   `--LITERAL_INT -> int [29:16]
        |       |   |--IDENT -> getPrice [29:20]
        |       |   |--LPAREN -> ( [29:28]
        |       |   |--PARAMETERS -> PARAMETERS [29:29]
        |       |   |--RPAREN -> ) [29:29]
        |       |   `--SLIST -> { [29:31]
        |       |       |--LITERAL_RETURN -> return [30:13]
        |       |       |   |--EXPR -> EXPR [30:20]
        |       |       |   |   `--IDENT -> price [30:20]
        |       |       |   `--SEMI -> ; [30:25]
        |       |       `--RCURLY -> } [31:9]
        |       |--METHOD_DEF -> METHOD_DEF [33:9]
        |       |   |--MODIFIERS -> MODIFIERS [33:9]
        |       |   |   `--LITERAL_PUBLIC -> public [33:9]
        |       |   |--TYPE -> TYPE [33:16]
        |       |   |   `--IDENT -> String [33:16]
        |       |   |--IDENT -> getModel [33:23]
        |       |   |--LPAREN -> ( [33:31]
        |       |   |--PARAMETERS -> PARAMETERS [33:32]
        |       |   |--RPAREN -> ) [33:32]
        |       |   `--SLIST -> { [33:34]
        |       |       |--LITERAL_RETURN -> return [34:13]
        |       |       |   |--EXPR -> EXPR [34:20]
        |       |       |   |   `--IDENT -> model [34:20]
        |       |       |   `--SEMI -> ; [34:25]
        |       |       `--RCURLY -> } [35:9]
        |       |--METHOD_DEF -> METHOD_DEF [37:9]
        |       |   |--MODIFIERS -> MODIFIERS [37:9]
        |       |   |   `--LITERAL_PUBLIC -> public [37:9]
        |       |   |--TYPE -> TYPE [37:16]
        |       |   |   `--LITERAL_VOID -> void [37:16]
        |       |   |--IDENT -> setModel [37:21]
        |       |   |--LPAREN -> ( [37:29]
        |       |   |--PARAMETERS -> PARAMETERS [37:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [37:30]
        |       |   |       |--MODIFIERS -> MODIFIERS [37:30]
        |       |   |       |--TYPE -> TYPE [37:30]
        |       |   |       |   `--IDENT -> String [37:30]
        |       |   |       `--IDENT -> model [37:37]
        |       |   |--RPAREN -> ) [37:42]
        |       |   `--SLIST -> { [37:44]
        |       |       |--EXPR -> EXPR [38:24]
        |       |       |   `--ASSIGN -> = [38:24]
        |       |       |       |--DOT -> . [38:17]
        |       |       |       |   |--LITERAL_THIS -> this [38:13]
        |       |       |       |   `--IDENT -> model [38:18]
        |       |       |       `--IDENT -> model [38:26]
        |       |       |--SEMI -> ; [38:31]
        |       |       `--RCURLY -> } [39:9]
        |       `--RCURLY -> } [40:5]
        |--STATIC_INIT -> STATIC_INIT [42:5]
        |   `--SLIST -> { [42:12]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [43:9]
        |       |   |--MODIFIERS -> MODIFIERS [43:9]
        |       |   |--TYPE -> TYPE [43:9]
        |       |   |   `--IDENT -> Object [43:9]
        |       |   |--IDENT -> o [43:16]
        |       |   `--ASSIGN -> = [43:18]
        |       |       `--EXPR -> EXPR [43:20]
        |       |           `--STRING_LITERAL -> "" [43:20]
        |       |--SEMI -> ; [43:22]
        |       |--LITERAL_IF -> if [45:9]
        |       |   |--LPAREN -> ( [45:12]
        |       |   |--EXPR -> EXPR [45:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [45:15]
        |       |   |       |--IDENT -> o [45:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [45:26]
        |       |   |           |--TYPE -> TYPE [45:26]
        |       |   |           |   `--IDENT -> String [45:26]
        |       |   |           `--IDENT -> s [45:33]
        |       |   |--RPAREN -> ) [45:34]
        |       |   `--SLIST -> { [45:36]
        |       |       |--EXPR -> EXPR [46:31]
        |       |       |   `--METHOD_CALL -> ( [46:31]
        |       |       |       |--DOT -> . [46:23]
        |       |       |       |   |--DOT -> . [46:19]
        |       |       |       |   |   |--IDENT -> System [46:13]
        |       |       |       |   |   `--IDENT -> out [46:20]
        |       |       |       |   `--IDENT -> println [46:24]
        |       |       |       |--ELIST -> ELIST [46:45]
        |       |       |       |   `--EXPR -> EXPR [46:45]
        |       |       |       |       `--METHOD_CALL -> ( [46:45]
        |       |       |       |           |--DOT -> . [46:33]
        |       |       |       |           |   |--IDENT -> s [46:32]
        |       |       |       |           |   `--IDENT -> toLowerCase [46:34]
        |       |       |       |           |--ELIST -> ELIST [46:67]
        |       |       |       |           |   `--EXPR -> EXPR [46:67]
        |       |       |       |           |       `--METHOD_CALL -> ( [46:67]
        |       |       |       |           |           |--DOT -> . [46:52]
        |       |       |       |           |           |   |--IDENT -> Locale [46:46]
        |       |       |       |           |           |   `--IDENT -> forLanguageTag [46:53]
        |       |       |       |           |           |--ELIST -> ELIST [46:68]
        |       |       |       |           |           |   `--EXPR -> EXPR [46:68]
        |       |       |       |           |           |       `--IDENT -> s [46:68]
        |       |       |       |           |           `--RPAREN -> ) [46:69]
        |       |       |       |           `--RPAREN -> ) [46:70]
        |       |       |       `--RPAREN -> ) [46:71]
        |       |       |--SEMI -> ; [46:72]
        |       |       |--VARIABLE_DEF -> VARIABLE_DEF [47:13]
        |       |       |   |--MODIFIERS -> MODIFIERS [47:13]
        |       |       |   |--TYPE -> TYPE [47:13]
        |       |       |   |   `--LITERAL_BOOLEAN -> boolean [47:13]
        |       |       |   |--IDENT -> stringCheck [47:21]
        |       |       |   `--ASSIGN -> = [47:33]
        |       |       |       `--EXPR -> EXPR [47:48]
        |       |       |           `--METHOD_CALL -> ( [47:48]
        |       |       |               |--DOT -> . [47:41]
        |       |       |               |   |--STRING_LITERAL -> "test" [47:35]
        |       |       |               |   `--IDENT -> equals [47:42]
        |       |       |               |--ELIST -> ELIST [47:49]
        |       |       |               |   `--EXPR -> EXPR [47:49]
        |       |       |               |       `--IDENT -> s [47:49]
        |       |       |               `--RPAREN -> ) [47:50]
        |       |       |--SEMI -> ; [47:51]
        |       |       `--RCURLY -> } [48:9]
        |       |--LITERAL_IF -> if [50:9]
        |       |   |--LPAREN -> ( [50:12]
        |       |   |--EXPR -> EXPR [50:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [50:15]
        |       |   |       |--IDENT -> o [50:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [50:26]
        |       |   |           |--TYPE -> TYPE [50:26]
        |       |   |           |   `--IDENT -> Integer [50:26]
        |       |   |           `--IDENT -> count [50:34]
        |       |   |--RPAREN -> ) [50:39]
        |       |   `--SLIST -> { [50:41]
        |       |       |--VARIABLE_DEF -> VARIABLE_DEF [51:13]
        |       |       |   |--MODIFIERS -> MODIFIERS [51:13]
        |       |       |   |--TYPE -> TYPE [51:13]
        |       |       |   |   `--LITERAL_INT -> int [51:13]
        |       |       |   |--IDENT -> value [51:17]
        |       |       |   `--ASSIGN -> = [51:23]
        |       |       |       `--EXPR -> EXPR [51:40]
        |       |       |           `--METHOD_CALL -> ( [51:40]
        |       |       |               |--DOT -> . [51:30]
        |       |       |               |   |--IDENT -> count [51:25]
        |       |       |               |   `--IDENT -> byteValue [51:31]
        |       |       |               |--ELIST -> ELIST [51:41]
        |       |       |               `--RPAREN -> ) [51:41]
        |       |       |--SEMI -> ; [51:42]
        |       |       |--LITERAL_IF -> if [52:13]
        |       |       |   |--LPAREN -> ( [52:16]
        |       |       |   |--EXPR -> EXPR [52:29]
        |       |       |   |   `--METHOD_CALL -> ( [52:29]
        |       |       |   |       |--DOT -> . [52:22]
        |       |       |   |       |   |--IDENT -> count [52:17]
        |       |       |   |       |   `--IDENT -> equals [52:23]
        |       |       |   |       |--ELIST -> ELIST [52:30]
        |       |       |   |       |   `--EXPR -> EXPR [52:30]
        |       |       |   |       |       `--IDENT -> value [52:30]
        |       |       |   |       `--RPAREN -> ) [52:35]
        |       |       |   |--RPAREN -> ) [52:36]
        |       |       |   `--SLIST -> { [52:38]
        |       |       |       |--EXPR -> EXPR [53:23]
        |       |       |       |   `--ASSIGN -> = [53:23]
        |       |       |       |       |--IDENT -> value [53:17]
        |       |       |       |       `--NUM_INT -> 25 [53:25]
        |       |       |       |--SEMI -> ; [53:27]
        |       |       |       `--RCURLY -> } [54:13]
        |       |       `--RCURLY -> } [55:9]
        |       |--LITERAL_IF -> if [58:9]
        |       |   |--LPAREN -> ( [58:12]
        |       |   |--EXPR -> EXPR [58:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [58:15]
        |       |   |       |--IDENT -> o [58:13]
        |       |   |       `--TYPE -> TYPE [58:26]
        |       |   |           `--IDENT -> String [58:26]
        |       |   |--RPAREN -> ) [58:32]
        |       |   `--SLIST -> { [58:34]
        |       |       |--EXPR -> EXPR [59:31]
        |       |       |   `--METHOD_CALL -> ( [59:31]
        |       |       |       |--DOT -> . [59:23]
        |       |       |       |   |--DOT -> . [59:19]
        |       |       |       |   |   |--IDENT -> System [59:13]
        |       |       |       |   |   `--IDENT -> out [59:20]
        |       |       |       |   `--IDENT -> println [59:24]
        |       |       |       |--ELIST -> ELIST [59:32]
        |       |       |       |   `--EXPR -> EXPR [59:32]
        |       |       |       |       `--STRING_LITERAL -> "Yes" [59:32]
        |       |       |       `--RPAREN -> ) [59:37]
        |       |       |--SEMI -> ; [59:38]
        |       |       `--RCURLY -> } [60:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [62:9]
        |       |   |--MODIFIERS -> MODIFIERS [62:9]
        |       |   |--TYPE -> TYPE [62:9]
        |       |   |   |--IDENT -> String [62:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [62:15]
        |       |   |       `--RBRACK -> ] [62:16]
        |       |   |--IDENT -> someString1 [62:18]
        |       |   `--ASSIGN -> = [62:30]
        |       |       `--ARRAY_INIT -> { [62:32]
        |       |           |--EXPR -> EXPR [62:33]
        |       |           |   `--STRING_LITERAL -> "some string" [62:33]
        |       |           `--RCURLY -> } [62:46]
        |       |--SEMI -> ; [62:47]
        |       |--LITERAL_IF -> if [63:9]
        |       |   |--LPAREN -> ( [63:12]
        |       |   |--EXPR -> EXPR [63:25]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [63:25]
        |       |   |       |--IDENT -> someString1 [63:13]
        |       |   |       `--TYPE -> TYPE [63:36]
        |       |   |           |--IDENT -> Object [63:36]
        |       |   |           `--ARRAY_DECLARATOR -> [ [63:42]
        |       |   |               `--RBRACK -> ] [63:43]
        |       |   |--RPAREN -> ) [63:44]
        |       |   `--SLIST -> { [63:46]
        |       |       |--EXPR -> EXPR [64:31]
        |       |       |   `--METHOD_CALL -> ( [64:31]
        |       |       |       |--DOT -> . [64:23]
        |       |       |       |   |--DOT -> . [64:19]
        |       |       |       |   |   |--IDENT -> System [64:13]
        |       |       |       |   |   `--IDENT -> out [64:20]
        |       |       |       |   `--IDENT -> println [64:24]
        |       |       |       |--ELIST -> ELIST [64:47]
        |       |       |       |   `--EXPR -> EXPR [64:47]
        |       |       |       |       `--METHOD_CALL -> ( [64:47]
        |       |       |       |           |--DOT -> . [64:38]
        |       |       |       |           |   |--IDENT -> Arrays [64:32]
        |       |       |       |           |   `--IDENT -> toString [64:39]
        |       |       |       |           |--ELIST -> ELIST [64:48]
        |       |       |       |           |   `--EXPR -> EXPR [64:48]
        |       |       |       |           |       `--IDENT -> someString1 [64:48]
        |       |       |       |           `--RPAREN -> ) [64:59]
        |       |       |       `--RPAREN -> ) [64:60]
        |       |       |--SEMI -> ; [64:61]
        |       |       `--RCURLY -> } [65:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [67:9]
        |       |   |--MODIFIERS -> MODIFIERS [67:9]
        |       |   |--TYPE -> TYPE [67:9]
        |       |   |   |--IDENT -> String [67:9]
        |       |   |   |--ARRAY_DECLARATOR -> [ [67:15]
        |       |   |   |   `--RBRACK -> ] [67:16]
        |       |   |   `--ARRAY_DECLARATOR -> [ [67:17]
        |       |   |       `--RBRACK -> ] [67:18]
        |       |   |--IDENT -> someString2 [67:20]
        |       |   `--ASSIGN -> = [67:32]
        |       |       `--EXPR -> EXPR [67:34]
        |       |           `--LITERAL_NEW -> new [67:34]
        |       |               |--IDENT -> String [67:38]
        |       |               |--ARRAY_DECLARATOR -> [ [67:44]
        |       |               |   |--EXPR -> EXPR [67:45]
        |       |               |   |   `--NUM_INT -> 2 [67:45]
        |       |               |   `--RBRACK -> ] [67:46]
        |       |               `--ARRAY_DECLARATOR -> [ [67:47]
        |       |                   |--EXPR -> EXPR [67:48]
        |       |                   |   `--NUM_INT -> 3 [67:48]
        |       |                   `--RBRACK -> ] [67:49]
        |       |--SEMI -> ; [67:50]
        |       |--LITERAL_IF -> if [68:9]
        |       |   |--LPAREN -> ( [68:12]
        |       |   |--EXPR -> EXPR [68:25]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [68:25]
        |       |   |       |--IDENT -> someString2 [68:13]
        |       |   |       `--TYPE -> TYPE [68:36]
        |       |   |           |--IDENT -> Object [68:36]
        |       |   |           |--ARRAY_DECLARATOR -> [ [68:42]
        |       |   |           |   `--RBRACK -> ] [68:43]
        |       |   |           `--ARRAY_DECLARATOR -> [ [68:44]
        |       |   |               `--RBRACK -> ] [68:45]
        |       |   |--RPAREN -> ) [68:46]
        |       |   `--SLIST -> { [68:48]
        |       |       |--EXPR -> EXPR [69:31]
        |       |       |   `--METHOD_CALL -> ( [69:31]
        |       |       |       |--DOT -> . [69:23]
        |       |       |       |   |--DOT -> . [69:19]
        |       |       |       |   |   |--IDENT -> System [69:13]
        |       |       |       |   |   `--IDENT -> out [69:20]
        |       |       |       |   `--IDENT -> println [69:24]
        |       |       |       |--ELIST -> ELIST [69:47]
        |       |       |       |   `--EXPR -> EXPR [69:47]
        |       |       |       |       `--METHOD_CALL -> ( [69:47]
        |       |       |       |           |--DOT -> . [69:38]
        |       |       |       |           |   |--IDENT -> Arrays [69:32]
        |       |       |       |           |   `--IDENT -> toString [69:39]
        |       |       |       |           |--ELIST -> ELIST [69:48]
        |       |       |       |           |   `--EXPR -> EXPR [69:48]
        |       |       |       |           |       `--IDENT -> someString2 [69:48]
        |       |       |       |           `--RPAREN -> ) [69:59]
        |       |       |       `--RPAREN -> ) [69:60]
        |       |       |--SEMI -> ; [69:61]
        |       |       `--RCURLY -> } [70:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [72:9]
        |       |   |--MODIFIERS -> MODIFIERS [72:9]
        |       |   |--TYPE -> TYPE [72:9]
        |       |   |   |--IDENT -> String [72:9]
        |       |   |   |--ARRAY_DECLARATOR -> [ [72:15]
        |       |   |   |   `--RBRACK -> ] [72:16]
        |       |   |   |--ARRAY_DECLARATOR -> [ [72:17]
        |       |   |   |   `--RBRACK -> ] [72:18]
        |       |   |   `--ARRAY_DECLARATOR -> [ [72:19]
        |       |   |       `--RBRACK -> ] [72:20]
        |       |   |--IDENT -> someString3 [72:22]
        |       |   `--ASSIGN -> = [72:34]
        |       |       `--EXPR -> EXPR [72:36]
        |       |           `--LITERAL_NEW -> new [72:36]
        |       |               |--IDENT -> String [72:40]
        |       |               |--ARRAY_DECLARATOR -> [ [72:46]
        |       |               |   |--EXPR -> EXPR [72:47]
        |       |               |   |   `--NUM_INT -> 3 [72:47]
        |       |               |   `--RBRACK -> ] [72:48]
        |       |               |--ARRAY_DECLARATOR -> [ [72:49]
        |       |               |   |--EXPR -> EXPR [72:50]
        |       |               |   |   `--NUM_INT -> 4 [72:50]
        |       |               |   `--RBRACK -> ] [72:51]
        |       |               `--ARRAY_DECLARATOR -> [ [72:52]
        |       |                   |--EXPR -> EXPR [72:53]
        |       |                   |   `--NUM_INT -> 5 [72:53]
        |       |                   `--RBRACK -> ] [72:54]
        |       |--SEMI -> ; [72:55]
        |       |--LITERAL_IF -> if [73:9]
        |       |   |--LPAREN -> ( [73:12]
        |       |   |--EXPR -> EXPR [73:25]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [73:25]
        |       |   |       |--IDENT -> someString3 [73:13]
        |       |   |       `--TYPE -> TYPE [73:36]
        |       |   |           |--IDENT -> Object [73:36]
        |       |   |           |--ARRAY_DECLARATOR -> [ [73:42]
        |       |   |           |   `--RBRACK -> ] [73:43]
        |       |   |           `--ARRAY_DECLARATOR -> [ [73:44]
        |       |   |               `--RBRACK -> ] [73:45]
        |       |   |--RPAREN -> ) [73:46]
        |       |   `--SLIST -> { [73:48]
        |       |       |--EXPR -> EXPR [74:31]
        |       |       |   `--METHOD_CALL -> ( [74:31]
        |       |       |       |--DOT -> . [74:23]
        |       |       |       |   |--DOT -> . [74:19]
        |       |       |       |   |   |--IDENT -> System [74:13]
        |       |       |       |   |   `--IDENT -> out [74:20]
        |       |       |       |   `--IDENT -> println [74:24]
        |       |       |       |--ELIST -> ELIST [74:47]
        |       |       |       |   `--EXPR -> EXPR [74:47]
        |       |       |       |       `--METHOD_CALL -> ( [74:47]
        |       |       |       |           |--DOT -> . [74:38]
        |       |       |       |           |   |--IDENT -> Arrays [74:32]
        |       |       |       |           |   `--IDENT -> toString [74:39]
        |       |       |       |           |--ELIST -> ELIST [74:48]
        |       |       |       |           |   `--EXPR -> EXPR [74:48]
        |       |       |       |           |       `--IDENT -> someString3 [74:48]
        |       |       |       |           `--RPAREN -> ) [74:59]
        |       |       |       `--RPAREN -> ) [74:60]
        |       |       |--SEMI -> ; [74:61]
        |       |       `--RCURLY -> } [75:9]
        |       `--RCURLY -> } [76:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [78:5]
        |   |--MODIFIERS -> MODIFIERS [78:5]
        |   |--LITERAL_INTERFACE -> interface [78:5]
        |   |--IDENT -> VoidPredicate [78:15]
        |   `--OBJBLOCK -> OBJBLOCK [78:29]
        |       |--LCURLY -> { [78:29]
        |       |--METHOD_DEF -> METHOD_DEF [79:9]
        |       |   |--MODIFIERS -> MODIFIERS [79:9]
        |       |   |   `--LITERAL_PUBLIC -> public [79:9]
        |       |   |--TYPE -> TYPE [79:16]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [79:16]
        |       |   |--IDENT -> get [79:24]
        |       |   |--LPAREN -> ( [79:27]
        |       |   |--PARAMETERS -> PARAMETERS [79:28]
        |       |   |--RPAREN -> ) [79:28]
        |       |   `--SEMI -> ; [79:29]
        |       `--RCURLY -> } [80:5]
        |--METHOD_DEF -> METHOD_DEF [82:5]
        |   |--MODIFIERS -> MODIFIERS [82:5]
        |   |   `--LITERAL_PUBLIC -> public [82:5]
        |   |--TYPE -> TYPE [82:12]
        |   |   `--LITERAL_VOID -> void [82:12]
        |   |--IDENT -> t [82:17]
        |   |--LPAREN -> ( [82:18]
        |   |--PARAMETERS -> PARAMETERS [82:19]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [82:19]
        |   |   |   |--MODIFIERS -> MODIFIERS [82:19]
        |   |   |   |--TYPE -> TYPE [82:19]
        |   |   |   |   `--IDENT -> Object [82:19]
        |   |   |   `--IDENT -> o1 [82:26]
        |   |   |--COMMA -> , [82:28]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [82:30]
        |   |       |--MODIFIERS -> MODIFIERS [82:30]
        |   |       |--TYPE -> TYPE [82:30]
        |   |       |   `--IDENT -> Object [82:30]
        |   |       `--IDENT -> o2 [82:37]
        |   |--RPAREN -> ) [82:39]
        |   `--SLIST -> { [82:41]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [83:9]
        |       |   |--MODIFIERS -> MODIFIERS [83:9]
        |       |   |--TYPE -> TYPE [83:9]
        |       |   |   `--IDENT -> Object [83:9]
        |       |   `--IDENT -> b [83:16]
        |       |--SEMI -> ; [83:17]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [84:9]
        |       |   |--MODIFIERS -> MODIFIERS [84:9]
        |       |   |--TYPE -> TYPE [84:9]
        |       |   |   `--IDENT -> Object [84:9]
        |       |   `--IDENT -> c [84:16]
        |       |--SEMI -> ; [84:17]
        |       |--LITERAL_IF -> if [85:9]
        |       |   |--LPAREN -> ( [85:12]
        |       |   |--EXPR -> EXPR [85:39]
        |       |   |   `--LAND -> && [85:39]
        |       |   |       |--LNOT -> ! [85:13]
        |       |   |       |   |--LPAREN -> ( [85:14]
        |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [85:18]
        |       |   |       |   |   |--IDENT -> o1 [85:15]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [85:29]
        |       |   |       |   |       |--TYPE -> TYPE [85:29]
        |       |   |       |   |       |   `--IDENT -> String [85:29]
        |       |   |       |   |       `--IDENT -> s [85:36]
        |       |   |       |   `--RPAREN -> ) [85:37]
        |       |   |       |--LPAREN -> ( [85:42]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [85:46]
        |       |   |       |   |--IDENT -> o2 [85:43]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:57]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [85:57]
        |       |   |       |       |--TYPE -> TYPE [85:57]
        |       |   |       |       |   `--IDENT -> String [85:57]
        |       |   |       |       `--IDENT -> s [85:64]
        |       |   |       `--RPAREN -> ) [85:65]
        |       |   |--RPAREN -> ) [85:66]
        |       |   `--SLIST -> { [85:68]
        |       |       `--RCURLY -> } [85:69]
        |       |--LITERAL_IF -> if [86:9]
        |       |   |--LPAREN -> ( [86:12]
        |       |   |--EXPR -> EXPR [86:36]
        |       |   |   `--LOR -> || [86:36]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [86:16]
        |       |   |       |   |--IDENT -> o1 [86:13]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [86:27]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [86:27]
        |       |   |       |       |--TYPE -> TYPE [86:27]
        |       |   |       |       |   `--IDENT -> String [86:27]
        |       |   |       |       `--IDENT -> s [86:34]
        |       |   |       `--LNOT -> ! [86:39]
        |       |   |           |--LPAREN -> ( [86:40]
        |       |   |           |--LITERAL_INSTANCEOF -> instanceof [86:44]
        |       |   |           |   |--IDENT -> o2 [86:41]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [86:55]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [86:55]
        |       |   |           |       |--TYPE -> TYPE [86:55]
        |       |   |           |       |   `--IDENT -> String [86:55]
        |       |   |           |       `--IDENT -> s [86:62]
        |       |   |           `--RPAREN -> ) [86:63]
        |       |   |--RPAREN -> ) [86:64]
        |       |   `--SLIST -> { [86:66]
        |       |       `--RCURLY -> } [86:67]
        |       |--EXPR -> EXPR [87:11]
        |       |   `--ASSIGN -> = [87:11]
        |       |       |--IDENT -> b [87:9]
        |       |       `--METHOD_CALL -> ( [87:63]
        |       |           |--DOT -> . [87:59]
        |       |           |   |--LPAREN -> ( [87:13]
        |       |           |   |--TYPECAST -> ( [87:14]
        |       |           |   |   |--TYPE -> TYPE [87:15]
        |       |           |   |   |   `--IDENT -> VoidPredicate [87:15]
        |       |           |   |   |--RPAREN -> ) [87:28]
        |       |           |   |   `--LAMBDA -> -> [87:33]
        |       |           |   |       |--LPAREN -> ( [87:30]
        |       |           |   |       |--PARAMETERS -> PARAMETERS [87:31]
        |       |           |   |       |--RPAREN -> ) [87:31]
        |       |           |   |       `--EXPR -> EXPR [87:39]
        |       |           |   |           `--LITERAL_INSTANCEOF -> instanceof [87:39]
        |       |           |   |               |--IDENT -> o1 [87:36]
        |       |           |   |               `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [87:50]
        |       |           |   |                   |--MODIFIERS -> MODIFIERS [87:50]
        |       |           |   |                   |--TYPE -> TYPE [87:50]
        |       |           |   |                   |   `--IDENT -> String [87:50]
        |       |           |   |                   `--IDENT -> s [87:57]
        |       |           |   |--RPAREN -> ) [87:58]
        |       |           |   `--IDENT -> get [87:60]
        |       |           |--ELIST -> ELIST [87:64]
        |       |           `--RPAREN -> ) [87:64]
        |       |--SEMI -> ; [87:65]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [89:9]
        |       |   |--MODIFIERS -> MODIFIERS [89:9]
        |       |   |--TYPE -> TYPE [89:9]
        |       |   |   |--IDENT -> List [89:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:13]
        |       |   |       |--GENERIC_START -> < [89:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:14]
        |       |   |       |   `--IDENT -> Integer [89:14]
        |       |   |       `--GENERIC_END -> > [89:21]
        |       |   |--IDENT -> arrayList [89:23]
        |       |   `--ASSIGN -> = [89:33]
        |       |       `--EXPR -> EXPR [89:35]
        |       |           `--LITERAL_NEW -> new [89:35]
        |       |               |--IDENT -> ArrayList [89:39]
        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:48]
        |       |               |   |--GENERIC_START -> < [89:48]
        |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:49]
        |       |               |   |   `--IDENT -> Integer [89:49]
        |       |               |   `--GENERIC_END -> > [89:56]
        |       |               |--LPAREN -> ( [89:57]
        |       |               |--ELIST -> ELIST [89:58]
        |       |               `--RPAREN -> ) [89:58]
        |       |--SEMI -> ; [89:59]
        |       |--LITERAL_IF -> if [90:9]
        |       |   |--LPAREN -> ( [90:12]
        |       |   |--EXPR -> EXPR [90:23]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [90:23]
        |       |   |       |--IDENT -> arrayList [90:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [90:34]
        |       |   |           |--MODIFIERS -> MODIFIERS [90:34]
        |       |   |           |--TYPE -> TYPE [90:34]
        |       |   |           |   |--IDENT -> ArrayList [90:34]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [90:43]
        |       |   |           |       |--GENERIC_START -> < [90:43]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [90:44]
        |       |   |           |       |   `--IDENT -> Integer [90:44]
        |       |   |           |       `--GENERIC_END -> > [90:51]
        |       |   |           `--IDENT -> ai [90:53]
        |       |   |--RPAREN -> ) [90:55]
        |       |   `--SLIST -> { [90:57]
        |       |       |--EXPR -> EXPR [91:31]
        |       |       |   `--METHOD_CALL -> ( [91:31]
        |       |       |       |--DOT -> . [91:23]
        |       |       |       |   |--DOT -> . [91:19]
        |       |       |       |   |   |--IDENT -> System [91:13]
        |       |       |       |   |   `--IDENT -> out [91:20]
        |       |       |       |   `--IDENT -> println [91:24]
        |       |       |       |--ELIST -> ELIST [91:32]
        |       |       |       |   `--EXPR -> EXPR [91:32]
        |       |       |       |       `--STRING_LITERAL -> "Blah" [91:32]
        |       |       |       `--RPAREN -> ) [91:38]
        |       |       |--SEMI -> ; [91:39]
        |       |       `--RCURLY -> } [92:9]
        |       |--LITERAL_IF -> if [94:9]
        |       |   |--LPAREN -> ( [94:12]
        |       |   |--EXPR -> EXPR [94:13]
        |       |   |   `--LNOT -> ! [94:13]
        |       |   |       |--LPAREN -> ( [94:14]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [94:18]
        |       |   |       |   |--IDENT -> o1 [94:15]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [94:29]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [94:29]
        |       |   |       |       |--TYPE -> TYPE [94:29]
        |       |   |       |       |   `--IDENT -> String [94:29]
        |       |   |       |       `--IDENT -> k [94:36]
        |       |   |       `--RPAREN -> ) [94:37]
        |       |   |--RPAREN -> ) [94:38]
        |       |   `--SLIST -> { [94:40]
        |       |       |--LITERAL_RETURN -> return [95:13]
        |       |       |   `--SEMI -> ; [95:20]
        |       |       `--RCURLY -> } [96:9]
        |       |--LITERAL_IF -> if [98:9]
        |       |   |--LPAREN -> ( [98:12]
        |       |   |--EXPR -> EXPR [98:16]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [98:16]
        |       |   |       |--IDENT -> o1 [98:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [98:27]
        |       |   |           |--MODIFIERS -> MODIFIERS [98:27]
        |       |   |           |--TYPE -> TYPE [98:27]
        |       |   |           |   `--IDENT -> String [98:27]
        |       |   |           `--IDENT -> s2 [98:34]
        |       |   |--RPAREN -> ) [98:36]
        |       |   `--SLIST -> { [98:38]
        |       |       `--RCURLY -> } [98:39]
        |       |--LITERAL_IF -> if [101:9]
        |       |   |--LPAREN -> ( [101:12]
        |       |   |--EXPR -> EXPR [101:13]
        |       |   |   `--LNOT -> ! [101:13]
        |       |   |       |--LPAREN -> ( [101:14]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [101:18]
        |       |   |       |   |--IDENT -> o1 [101:15]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [101:29]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [101:29]
        |       |   |       |       |--TYPE -> TYPE [101:29]
        |       |   |       |       |   `--IDENT -> String [101:29]
        |       |   |       |       `--IDENT -> s4 [101:36]
        |       |   |       `--RPAREN -> ) [101:38]
        |       |   |--RPAREN -> ) [101:39]
        |       |   `--SLIST -> { [101:41]
        |       |       |--LITERAL_RETURN -> return [102:13]
        |       |       |   `--SEMI -> ; [102:20]
        |       |       `--RCURLY -> } [103:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [105:9]
        |       |   |--MODIFIERS -> MODIFIERS [105:9]
        |       |   |--TYPE -> TYPE [105:9]
        |       |   |   `--LITERAL_BOOLEAN -> boolean [105:9]
        |       |   |--IDENT -> result [105:17]
        |       |   `--ASSIGN -> = [105:24]
        |       |       `--EXPR -> EXPR [105:52]
        |       |           `--QUESTION -> ? [105:52]
        |       |               |--LPAREN -> ( [105:26]
        |       |               |--LITERAL_INSTANCEOF -> instanceof [105:30]
        |       |               |   |--IDENT -> o1 [105:27]
        |       |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [105:41]
        |       |               |       |--MODIFIERS -> MODIFIERS [105:41]
        |       |               |       |--TYPE -> TYPE [105:41]
        |       |               |       |   `--IDENT -> String [105:41]
        |       |               |       `--IDENT -> a1 [105:48]
        |       |               |--RPAREN -> ) [105:50]
        |       |               |--LPAREN -> ( [106:17]
        |       |               |--LITERAL_INSTANCEOF -> instanceof [106:21]
        |       |               |   |--IDENT -> o1 [106:18]
        |       |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [106:32]
        |       |               |       |--MODIFIERS -> MODIFIERS [106:32]
        |       |               |       |--TYPE -> TYPE [106:32]
        |       |               |       |   `--IDENT -> String [106:32]
        |       |               |       `--IDENT -> a2 [106:39]
        |       |               |--RPAREN -> ) [106:41]
        |       |               |--COLON -> : [106:43]
        |       |               |--LPAREN -> ( [106:45]
        |       |               |--LNOT -> ! [106:46]
        |       |               |   |--LPAREN -> ( [106:47]
        |       |               |   |--LITERAL_INSTANCEOF -> instanceof [106:51]
        |       |               |   |   |--IDENT -> o1 [106:48]
        |       |               |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [106:62]
        |       |               |   |       |--MODIFIERS -> MODIFIERS [106:62]
        |       |               |   |       |--TYPE -> TYPE [106:62]
        |       |               |   |       |   `--IDENT -> String [106:62]
        |       |               |   |       `--IDENT -> a3 [106:69]
        |       |               |   `--RPAREN -> ) [106:71]
        |       |               `--RPAREN -> ) [106:72]
        |       |--SEMI -> ; [106:73]
        |       |--LITERAL_IF -> if [108:9]
        |       |   |--LPAREN -> ( [108:12]
        |       |   |--EXPR -> EXPR [108:39]
        |       |   |   `--QUESTION -> ? [108:39]
        |       |   |       |--LNOT -> ! [108:13]
        |       |   |       |   |--LPAREN -> ( [108:14]
        |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [108:18]
        |       |   |       |   |   |--IDENT -> o1 [108:15]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [108:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [108:29]
        |       |   |       |   |       |--TYPE -> TYPE [108:29]
        |       |   |       |   |       |   `--IDENT -> String [108:29]
        |       |   |       |   |       `--IDENT -> s [108:36]
        |       |   |       |   `--RPAREN -> ) [108:37]
        |       |   |       |--LITERAL_FALSE -> false [108:41]
        |       |   |       |--COLON -> : [108:47]
        |       |   |       `--GT -> > [108:59]
        |       |   |           |--METHOD_CALL -> ( [108:57]
        |       |   |           |   |--DOT -> . [108:50]
        |       |   |           |   |   |--IDENT -> s [108:49]
        |       |   |           |   |   `--IDENT -> length [108:51]
        |       |   |           |   |--ELIST -> ELIST [108:58]
        |       |   |           |   `--RPAREN -> ) [108:58]
        |       |   |           `--NUM_INT -> 0 [108:60]
        |       |   |--RPAREN -> ) [108:61]
        |       |   `--SLIST -> { [108:62]
        |       |       |--EXPR -> EXPR [109:31]
        |       |       |   `--METHOD_CALL -> ( [109:31]
        |       |       |       |--DOT -> . [109:23]
        |       |       |       |   |--DOT -> . [109:19]
        |       |       |       |   |   |--IDENT -> System [109:13]
        |       |       |       |   |   `--IDENT -> out [109:20]
        |       |       |       |   `--IDENT -> println [109:24]
        |       |       |       |--ELIST -> ELIST [109:32]
        |       |       |       |   `--EXPR -> EXPR [109:32]
        |       |       |       |       `--STRING_LITERAL -> "done" [109:32]
        |       |       |       `--RPAREN -> ) [109:38]
        |       |       |--SEMI -> ; [109:39]
        |       |       `--RCURLY -> } [110:9]
        |       |--LITERAL_IF -> if [112:9]
        |       |   |--LPAREN -> ( [112:12]
        |       |   |--EXPR -> EXPR [112:38]
        |       |   |   `--QUESTION -> ? [112:38]
        |       |   |       |--LPAREN -> ( [112:13]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [112:17]
        |       |   |       |   |--IDENT -> o1 [112:14]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:28]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [112:28]
        |       |   |       |       |--TYPE -> TYPE [112:28]
        |       |   |       |       |   `--IDENT -> String [112:28]
        |       |   |       |       `--IDENT -> s [112:35]
        |       |   |       |--RPAREN -> ) [112:36]
        |       |   |       |--GT -> > [112:50]
        |       |   |       |   |--METHOD_CALL -> ( [112:48]
        |       |   |       |   |   |--DOT -> . [112:41]
        |       |   |       |   |   |   |--IDENT -> s [112:40]
        |       |   |       |   |   |   `--IDENT -> length [112:42]
        |       |   |       |   |   |--ELIST -> ELIST [112:49]
        |       |   |       |   |   `--RPAREN -> ) [112:49]
        |       |   |       |   `--NUM_INT -> 0 [112:51]
        |       |   |       |--COLON -> : [112:53]
        |       |   |       `--LITERAL_FALSE -> false [112:55]
        |       |   |--RPAREN -> ) [112:60]
        |       |   `--SLIST -> { [112:61]
        |       |       |--EXPR -> EXPR [113:31]
        |       |       |   `--METHOD_CALL -> ( [113:31]
        |       |       |       |--DOT -> . [113:23]
        |       |       |       |   |--DOT -> . [113:19]
        |       |       |       |   |   |--IDENT -> System [113:13]
        |       |       |       |   |   `--IDENT -> out [113:20]
        |       |       |       |   `--IDENT -> println [113:24]
        |       |       |       |--ELIST -> ELIST [113:32]
        |       |       |       |   `--EXPR -> EXPR [113:32]
        |       |       |       |       `--STRING_LITERAL -> "done" [113:32]
        |       |       |       `--RPAREN -> ) [113:38]
        |       |       |--SEMI -> ; [113:39]
        |       |       `--RCURLY -> } [114:9]
        |       |--LITERAL_IF -> if [116:9]
        |       |   |--LPAREN -> ( [116:12]
        |       |   |--EXPR -> EXPR [116:39]
        |       |   |   `--LOR -> || [116:39]
        |       |   |       |--LNOT -> ! [116:13]
        |       |   |       |   |--LPAREN -> ( [116:14]
        |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [116:18]
        |       |   |       |   |   |--IDENT -> o1 [116:15]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [116:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [116:29]
        |       |   |       |   |       |--TYPE -> TYPE [116:29]
        |       |   |       |   |       |   `--IDENT -> String [116:29]
        |       |   |       |   |       `--IDENT -> s [116:36]
        |       |   |       |   `--RPAREN -> ) [116:37]
        |       |   |       `--LNOT -> ! [116:42]
        |       |   |           |--LPAREN -> ( [116:43]
        |       |   |           |--LITERAL_INSTANCEOF -> instanceof [116:47]
        |       |   |           |   |--IDENT -> o2 [116:44]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [116:58]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [116:58]
        |       |   |           |       |--TYPE -> TYPE [116:58]
        |       |   |           |       |   `--IDENT -> Integer [116:58]
        |       |   |           |       `--IDENT -> i [116:66]
        |       |   |           `--RPAREN -> ) [116:67]
        |       |   |--RPAREN -> ) [116:68]
        |       |   |--SLIST -> { [116:69]
        |       |   |   `--RCURLY -> } [117:9]
        |       |   `--LITERAL_ELSE -> else [117:11]
        |       |       `--SLIST -> { [117:16]
        |       |           |--EXPR -> EXPR [118:21]
        |       |           |   `--METHOD_CALL -> ( [118:21]
        |       |           |       |--DOT -> . [118:14]
        |       |           |       |   |--IDENT -> s [118:13]
        |       |           |       |   `--IDENT -> length [118:15]
        |       |           |       |--ELIST -> ELIST [118:22]
        |       |           |       `--RPAREN -> ) [118:22]
        |       |           |--SEMI -> ; [118:23]
        |       |           |--EXPR -> EXPR [119:23]
        |       |           |   `--METHOD_CALL -> ( [119:23]
        |       |           |       |--DOT -> . [119:14]
        |       |           |       |   |--IDENT -> i [119:13]
        |       |           |       |   `--IDENT -> intValue [119:15]
        |       |           |       |--ELIST -> ELIST [119:24]
        |       |           |       `--RPAREN -> ) [119:24]
        |       |           |--SEMI -> ; [119:25]
        |       |           `--RCURLY -> } [120:9]
        |       |--LITERAL_IF -> if [122:9]
        |       |   |--LPAREN -> ( [122:12]
        |       |   |--EXPR -> EXPR [122:39]
        |       |   |   `--LOR -> || [122:39]
        |       |   |       |--LNOT -> ! [122:13]
        |       |   |       |   |--LPAREN -> ( [122:14]
        |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [122:18]
        |       |   |       |   |   |--IDENT -> o1 [122:15]
        |       |   |       |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [122:29]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [122:29]
        |       |   |       |   |       |--TYPE -> TYPE [122:29]
        |       |   |       |   |       |   `--IDENT -> String [122:29]
        |       |   |       |   |       `--IDENT -> s [122:36]
        |       |   |       |   `--RPAREN -> ) [122:37]
        |       |   |       `--LNOT -> ! [122:42]
        |       |   |           |--LPAREN -> ( [122:43]
        |       |   |           |--LITERAL_INSTANCEOF -> instanceof [122:47]
        |       |   |           |   |--IDENT -> o2 [122:44]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [122:58]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [122:58]
        |       |   |           |       |--TYPE -> TYPE [122:58]
        |       |   |           |       |   `--IDENT -> Integer [122:58]
        |       |   |           |       `--IDENT -> i [122:66]
        |       |   |           `--RPAREN -> ) [122:67]
        |       |   |--RPAREN -> ) [122:68]
        |       |   |--SLIST -> { [122:69]
        |       |   |   `--RCURLY -> } [123:9]
        |       |   `--LITERAL_ELSE -> else [123:11]
        |       |       `--SLIST -> { [123:16]
        |       |           |--EXPR -> EXPR [124:21]
        |       |           |   `--METHOD_CALL -> ( [124:21]
        |       |           |       |--DOT -> . [124:14]
        |       |           |       |   |--IDENT -> s [124:13]
        |       |           |       |   `--IDENT -> length [124:15]
        |       |           |       |--ELIST -> ELIST [124:22]
        |       |           |       `--RPAREN -> ) [124:22]
        |       |           |--SEMI -> ; [124:23]
        |       |           |--EXPR -> EXPR [125:23]
        |       |           |   `--METHOD_CALL -> ( [125:23]
        |       |           |       |--DOT -> . [125:14]
        |       |           |       |   |--IDENT -> i [125:13]
        |       |           |       |   `--IDENT -> intValue [125:15]
        |       |           |       |--ELIST -> ELIST [125:24]
        |       |           |       `--RPAREN -> ) [125:24]
        |       |           |--SEMI -> ; [125:25]
        |       |           `--RCURLY -> } [126:9]
        |       |--LITERAL_IF -> if [128:9]
        |       |   |--LPAREN -> ( [128:12]
        |       |   |--EXPR -> EXPR [128:36]
        |       |   |   `--LAND -> && [128:36]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [128:16]
        |       |   |       |   |--IDENT -> o1 [128:13]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [128:27]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [128:27]
        |       |   |       |       |--TYPE -> TYPE [128:27]
        |       |   |       |       |   `--IDENT -> String [128:27]
        |       |   |       |       `--IDENT -> s [128:34]
        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [128:42]
        |       |   |           |--IDENT -> o2 [128:39]
        |       |   |           `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [128:53]
        |       |   |               |--MODIFIERS -> MODIFIERS [128:53]
        |       |   |               |--TYPE -> TYPE [128:53]
        |       |   |               |   `--IDENT -> Integer [128:53]
        |       |   |               `--IDENT -> in [128:61]
        |       |   |--RPAREN -> ) [128:63]
        |       |   `--SLIST -> { [128:65]
        |       |       |--EXPR -> EXPR [129:21]
        |       |       |   `--METHOD_CALL -> ( [129:21]
        |       |       |       |--DOT -> . [129:14]
        |       |       |       |   |--IDENT -> s [129:13]
        |       |       |       |   `--IDENT -> length [129:15]
        |       |       |       |--ELIST -> ELIST [129:22]
        |       |       |       `--RPAREN -> ) [129:22]
        |       |       |--SEMI -> ; [129:23]
        |       |       |--EXPR -> EXPR [130:24]
        |       |       |   `--METHOD_CALL -> ( [130:24]
        |       |       |       |--DOT -> . [130:15]
        |       |       |       |   |--IDENT -> in [130:13]
        |       |       |       |   `--IDENT -> intValue [130:16]
        |       |       |       |--ELIST -> ELIST [130:25]
        |       |       |       `--RPAREN -> ) [130:25]
        |       |       |--SEMI -> ; [130:26]
        |       |       `--RCURLY -> } [131:9]
        |       |--LABELED_STAT -> : [133:11]
        |       |   |--IDENT -> L1 [133:9]
        |       |   `--SLIST -> { [133:13]
        |       |       |--LITERAL_IF -> if [134:13]
        |       |       |   |--LPAREN -> ( [134:16]
        |       |       |   |--EXPR -> EXPR [134:20]
        |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [134:20]
        |       |       |   |       |--IDENT -> o1 [134:17]
        |       |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [134:31]
        |       |       |   |           |--MODIFIERS -> MODIFIERS [134:31]
        |       |       |   |           |--TYPE -> TYPE [134:31]
        |       |       |   |           |   `--IDENT -> String [134:31]
        |       |       |   |           `--IDENT -> s [134:38]
        |       |       |   |--RPAREN -> ) [134:39]
        |       |       |   |--SLIST -> { [134:41]
        |       |       |   |   |--EXPR -> EXPR [135:25]
        |       |       |   |   |   `--METHOD_CALL -> ( [135:25]
        |       |       |   |   |       |--DOT -> . [135:18]
        |       |       |   |   |       |   |--IDENT -> s [135:17]
        |       |       |   |   |       |   `--IDENT -> length [135:19]
        |       |       |   |   |       |--ELIST -> ELIST [135:26]
        |       |       |   |   |       `--RPAREN -> ) [135:26]
        |       |       |   |   |--SEMI -> ; [135:27]
        |       |       |   |   `--RCURLY -> } [136:13]
        |       |       |   `--LITERAL_ELSE -> else [136:15]
        |       |       |       `--SLIST -> { [136:20]
        |       |       |           |--LITERAL_BREAK -> break [137:17]
        |       |       |           |   |--IDENT -> L1 [137:23]
        |       |       |           |   `--SEMI -> ; [137:25]
        |       |       |           `--RCURLY -> } [138:13]
        |       |       |--EXPR -> EXPR [139:21]
        |       |       |   `--METHOD_CALL -> ( [139:21]
        |       |       |       |--DOT -> . [139:14]
        |       |       |       |   |--IDENT -> s [139:13]
        |       |       |       |   `--IDENT -> length [139:15]
        |       |       |       |--ELIST -> ELIST [139:22]
        |       |       |       `--RPAREN -> ) [139:22]
        |       |       |--SEMI -> ; [139:23]
        |       |       `--RCURLY -> } [140:9]
        |       |--SLIST -> { [142:9]
        |       |   |--LABELED_STAT -> : [143:15]
        |       |   |   |--IDENT -> L2 [143:13]
        |       |   |   `--LITERAL_FOR -> for [143:17]
        |       |   |       |--LPAREN -> ( [143:21]
        |       |   |       |--FOR_INIT -> FOR_INIT [143:23]
        |       |   |       |--SEMI -> ; [143:23]
        |       |   |       |--FOR_CONDITION -> FOR_CONDITION [143:24]
        |       |   |       |   `--EXPR -> EXPR [143:24]
        |       |   |       |       `--LNOT -> ! [143:24]
        |       |   |       |           |--LPAREN -> ( [143:25]
        |       |   |       |           |--LITERAL_INSTANCEOF -> instanceof [143:29]
        |       |   |       |           |   |--IDENT -> o1 [143:26]
        |       |   |       |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [143:40]
        |       |   |       |           |       |--MODIFIERS -> MODIFIERS [143:40]
        |       |   |       |           |       |--TYPE -> TYPE [143:40]
        |       |   |       |           |       |   `--IDENT -> String [143:40]
        |       |   |       |           |       `--IDENT -> s [143:47]
        |       |   |       |           `--RPAREN -> ) [143:48]
        |       |   |       |--SEMI -> ; [143:49]
        |       |   |       |--FOR_ITERATOR -> FOR_ITERATOR [143:51]
        |       |   |       |--RPAREN -> ) [143:51]
        |       |   |       `--SLIST -> { [143:53]
        |       |   |           `--RCURLY -> } [145:13]
        |       |   |--EXPR -> EXPR [147:21]
        |       |   |   `--METHOD_CALL -> ( [147:21]
        |       |   |       |--DOT -> . [147:14]
        |       |   |       |   |--IDENT -> s [147:13]
        |       |   |       |   `--IDENT -> length [147:15]
        |       |   |       |--ELIST -> ELIST [147:22]
        |       |   |       `--RPAREN -> ) [147:22]
        |       |   |--SEMI -> ; [147:23]
        |       |   `--RCURLY -> } [148:9]
        |       |--SLIST -> { [150:9]
        |       |   |--LITERAL_WHILE -> while [151:13]
        |       |   |   |--LPAREN -> ( [151:19]
        |       |   |   |--EXPR -> EXPR [151:20]
        |       |   |   |   `--LNOT -> ! [151:20]
        |       |   |   |       |--LPAREN -> ( [151:21]
        |       |   |   |       |--LITERAL_INSTANCEOF -> instanceof [151:25]
        |       |   |   |       |   |--IDENT -> o1 [151:22]
        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [151:36]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [151:36]
        |       |   |   |       |       |--TYPE -> TYPE [151:36]
        |       |   |   |       |       |   `--IDENT -> String [151:36]
        |       |   |   |       |       `--IDENT -> s [151:43]
        |       |   |   |       `--RPAREN -> ) [151:44]
        |       |   |   |--RPAREN -> ) [151:45]
        |       |   |   `--SLIST -> { [151:47]
        |       |   |       |--LABELED_STAT -> : [152:19]
        |       |   |       |   |--IDENT -> L3 [152:17]
        |       |   |       |   `--LITERAL_BREAK -> break [152:21]
        |       |   |       |       |--IDENT -> L3 [152:27]
        |       |   |       |       `--SEMI -> ; [152:29]
        |       |   |       `--RCURLY -> } [153:13]
        |       |   |--LITERAL_WHILE -> while [155:13]
        |       |   |   |--LPAREN -> ( [155:18]
        |       |   |   |--EXPR -> EXPR [155:22]
        |       |   |   |   `--LITERAL_INSTANCEOF -> instanceof [155:22]
        |       |   |   |       |--IDENT -> o1 [155:19]
        |       |   |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [155:33]
        |       |   |   |           |--MODIFIERS -> MODIFIERS [155:33]
        |       |   |   |           |--TYPE -> TYPE [155:33]
        |       |   |   |           |   `--IDENT -> String [155:33]
        |       |   |   |           `--IDENT -> str [155:40]
        |       |   |   |--RPAREN -> ) [155:43]
        |       |   |   `--SLIST -> { [155:45]
        |       |   |       |--EXPR -> EXPR [156:27]
        |       |   |       |   `--METHOD_CALL -> ( [156:27]
        |       |   |       |       |--DOT -> . [156:20]
        |       |   |       |       |   |--IDENT -> str [156:17]
        |       |   |       |       |   `--IDENT -> length [156:21]
        |       |   |       |       |--ELIST -> ELIST [156:28]
        |       |   |       |       `--RPAREN -> ) [156:28]
        |       |   |       |--SEMI -> ; [156:29]
        |       |   |       `--RCURLY -> } [157:13]
        |       |   `--RCURLY -> } [158:9]
        |       |--LITERAL_IF -> if [160:9]
        |       |   |--LPAREN -> ( [160:12]
        |       |   |--EXPR -> EXPR [160:13]
        |       |   |   `--LNOT -> ! [160:13]
        |       |   |       `--METHOD_CALL -> ( [161:42]
        |       |   |           |--DOT -> . [161:38]
        |       |   |           |   |--LITERAL_NEW -> new [160:14]
        |       |   |           |   |   |--IDENT -> VoidPredicate [160:18]
        |       |   |           |   |   |--LPAREN -> ( [160:31]
        |       |   |           |   |   |--ELIST -> ELIST [160:32]
        |       |   |           |   |   |--RPAREN -> ) [160:32]
        |       |   |           |   |   `--OBJBLOCK -> OBJBLOCK [160:34]
        |       |   |           |   |       |--LCURLY -> { [160:34]
        |       |   |           |   |       |--METHOD_DEF -> METHOD_DEF [160:36]
        |       |   |           |   |       |   |--MODIFIERS -> MODIFIERS [160:36]
        |       |   |           |   |       |   |   `--LITERAL_PUBLIC -> public [160:36]
        |       |   |           |   |       |   |--TYPE -> TYPE [160:43]
        |       |   |           |   |       |   |   `--LITERAL_BOOLEAN -> boolean [160:43]
        |       |   |           |   |       |   |--IDENT -> get [160:51]
        |       |   |           |   |       |   |--LPAREN -> ( [160:54]
        |       |   |           |   |       |   |--PARAMETERS -> PARAMETERS [160:55]
        |       |   |           |   |       |   |--RPAREN -> ) [160:55]
        |       |   |           |   |       |   `--SLIST -> { [160:57]
        |       |   |           |   |       |       |--LITERAL_RETURN -> return [160:59]
        |       |   |           |   |       |       |   |--EXPR -> EXPR [161:17]
        |       |   |           |   |       |       |   |   `--LAND -> && [161:17]
        |       |   |           |   |       |       |   |       |--LITERAL_INSTANCEOF -> instanceof [160:69]
        |       |   |           |   |       |       |   |       |   |--IDENT -> o1 [160:66]
        |       |   |           |   |       |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [160:80]
        |       |   |           |   |       |       |   |       |       |--MODIFIERS -> MODIFIERS [160:80]
        |       |   |           |   |       |       |   |       |       |--TYPE -> TYPE [160:80]
        |       |   |           |   |       |       |   |       |       |   `--IDENT -> String [160:80]
        |       |   |           |   |       |       |   |       |       `--IDENT -> str [160:87]
        |       |   |           |   |       |       |   |       `--LNOT -> ! [161:20]
        |       |   |           |   |       |       |   |           `--METHOD_CALL -> ( [161:32]
        |       |   |           |   |       |       |   |               |--DOT -> . [161:24]
        |       |   |           |   |       |       |   |               |   |--IDENT -> str [161:21]
        |       |   |           |   |       |       |   |               |   `--IDENT -> isEmpty [161:25]
        |       |   |           |   |       |       |   |               |--ELIST -> ELIST [161:33]
        |       |   |           |   |       |       |   |               `--RPAREN -> ) [161:33]
        |       |   |           |   |       |       |   `--SEMI -> ; [161:34]
        |       |   |           |   |       |       `--RCURLY -> } [161:35]
        |       |   |           |   |       `--RCURLY -> } [161:37]
        |       |   |           |   `--IDENT -> get [161:39]
        |       |   |           |--ELIST -> ELIST [161:43]
        |       |   |           `--RPAREN -> ) [161:43]
        |       |   |--RPAREN -> ) [161:44]
        |       |   `--SLIST -> { [161:46]
        |       |       |--LITERAL_THROW -> throw [162:13]
        |       |       |   |--EXPR -> EXPR [162:19]
        |       |       |   |   `--LITERAL_NEW -> new [162:19]
        |       |       |   |       |--IDENT -> AssertionError [162:23]
        |       |       |   |       |--LPAREN -> ( [162:37]
        |       |       |   |       |--ELIST -> ELIST [162:38]
        |       |       |   |       `--RPAREN -> ) [162:38]
        |       |       |   `--SEMI -> ; [162:39]
        |       |       `--RCURLY -> } [163:9]
        |       |--LITERAL_IF -> if [165:9]
        |       |   |--LPAREN -> ( [165:12]
        |       |   |--EXPR -> EXPR [165:13]
        |       |   |   `--LNOT -> ! [165:13]
        |       |   |       `--METHOD_CALL -> ( [165:84]
        |       |   |           |--DOT -> . [165:80]
        |       |   |           |   |--LPAREN -> ( [165:14]
        |       |   |           |   |--TYPECAST -> ( [165:15]
        |       |   |           |   |   |--TYPE -> TYPE [165:16]
        |       |   |           |   |   |   `--IDENT -> VoidPredicate [165:16]
        |       |   |           |   |   |--RPAREN -> ) [165:29]
        |       |   |           |   |   `--LAMBDA -> -> [165:34]
        |       |   |           |   |       |--LPAREN -> ( [165:31]
        |       |   |           |   |       |--PARAMETERS -> PARAMETERS [165:32]
        |       |   |           |   |       |--RPAREN -> ) [165:32]
        |       |   |           |   |       `--EXPR -> EXPR [165:62]
        |       |   |           |   |           `--LAND -> && [165:62]
        |       |   |           |   |               |--LITERAL_INSTANCEOF -> instanceof [165:40]
        |       |   |           |   |               |   |--IDENT -> o1 [165:37]
        |       |   |           |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [165:51]
        |       |   |           |   |               |       |--MODIFIERS -> MODIFIERS [165:51]
        |       |   |           |   |               |       |--TYPE -> TYPE [165:51]
        |       |   |           |   |               |       |   `--IDENT -> String [165:51]
        |       |   |           |   |               |       `--IDENT -> str [165:58]
        |       |   |           |   |               `--LNOT -> ! [165:65]
        |       |   |           |   |                   `--METHOD_CALL -> ( [165:77]
        |       |   |           |   |                       |--DOT -> . [165:69]
        |       |   |           |   |                       |   |--IDENT -> str [165:66]
        |       |   |           |   |                       |   `--IDENT -> isEmpty [165:70]
        |       |   |           |   |                       |--ELIST -> ELIST [165:78]
        |       |   |           |   |                       `--RPAREN -> ) [165:78]
        |       |   |           |   |--RPAREN -> ) [165:79]
        |       |   |           |   `--IDENT -> get [165:81]
        |       |   |           |--ELIST -> ELIST [165:85]
        |       |   |           `--RPAREN -> ) [165:85]
        |       |   |--RPAREN -> ) [165:86]
        |       |   `--SLIST -> { [165:88]
        |       |       |--LITERAL_THROW -> throw [166:13]
        |       |       |   |--EXPR -> EXPR [166:19]
        |       |       |   |   `--LITERAL_NEW -> new [166:19]
        |       |       |   |       |--IDENT -> AssertionError [166:23]
        |       |       |   |       |--LPAREN -> ( [166:37]
        |       |       |   |       |--ELIST -> ELIST [166:38]
        |       |       |   |       `--RPAREN -> ) [166:38]
        |       |       |   `--SEMI -> ; [166:39]
        |       |       `--RCURLY -> } [167:9]
        |       |--LITERAL_IF -> if [169:9]
        |       |   |--LPAREN -> ( [169:12]
        |       |   |--EXPR -> EXPR [169:82]
        |       |   |   `--LAND -> && [169:82]
        |       |   |       |--LAND -> && [169:55]
        |       |   |       |   |--LAND -> && [169:36]
        |       |   |       |   |   |--LITERAL_INSTANCEOF -> instanceof [169:16]
        |       |   |       |   |   |   |--IDENT -> o1 [169:13]
        |       |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [169:27]
        |       |   |       |   |   |       |--MODIFIERS -> MODIFIERS [169:27]
        |       |   |       |   |   |       |--TYPE -> TYPE [169:27]
        |       |   |       |   |   |       |   `--IDENT -> String [169:27]
        |       |   |       |   |   |       `--IDENT -> j [169:34]
        |       |   |       |   |   `--EQUAL -> == [169:50]
        |       |   |       |   |       |--METHOD_CALL -> ( [169:47]
        |       |   |       |   |       |   |--DOT -> . [169:40]
        |       |   |       |   |       |   |   |--IDENT -> j [169:39]
        |       |   |       |   |       |   |   `--IDENT -> length [169:41]
        |       |   |       |   |       |   |--ELIST -> ELIST [169:48]
        |       |   |       |   |       |   `--RPAREN -> ) [169:48]
        |       |   |       |   |       `--NUM_INT -> 5 [169:53]
        |       |   |       |   `--LITERAL_INSTANCEOF -> instanceof [169:61]
        |       |   |       |       |--IDENT -> o2 [169:58]
        |       |   |       |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [169:72]
        |       |   |       |           |--MODIFIERS -> MODIFIERS [169:72]
        |       |   |       |           |--TYPE -> TYPE [169:72]
        |       |   |       |           |   `--IDENT -> Integer [169:72]
        |       |   |       |           `--IDENT -> z [169:80]
        |       |   |       `--EQUAL -> == [169:87]
        |       |   |           |--IDENT -> z [169:85]
        |       |   |           `--NUM_INT -> 42 [169:90]
        |       |   |--RPAREN -> ) [169:92]
        |       |   |--SLIST -> { [169:94]
        |       |   |   |--EXPR -> EXPR [170:31]
        |       |   |   |   `--METHOD_CALL -> ( [170:31]
        |       |   |   |       |--DOT -> . [170:23]
        |       |   |   |       |   |--DOT -> . [170:19]
        |       |   |   |       |   |   |--IDENT -> System [170:13]
        |       |   |   |       |   |   `--IDENT -> out [170:20]
        |       |   |   |       |   `--IDENT -> println [170:24]
        |       |   |   |       |--ELIST -> ELIST [170:32]
        |       |   |   |       |   `--EXPR -> EXPR [170:32]
        |       |   |   |       |       `--IDENT -> j [170:32]
        |       |   |   |       `--RPAREN -> ) [170:33]
        |       |   |   |--SEMI -> ; [170:34]
        |       |   |   |--EXPR -> EXPR [171:31]
        |       |   |   |   `--METHOD_CALL -> ( [171:31]
        |       |   |   |       |--DOT -> . [171:23]
        |       |   |   |       |   |--DOT -> . [171:19]
        |       |   |   |       |   |   |--IDENT -> System [171:13]
        |       |   |   |       |   |   `--IDENT -> out [171:20]
        |       |   |   |       |   `--IDENT -> println [171:24]
        |       |   |   |       |--ELIST -> ELIST [171:32]
        |       |   |   |       |   `--EXPR -> EXPR [171:32]
        |       |   |   |       |       `--IDENT -> z [171:32]
        |       |   |   |       `--RPAREN -> ) [171:33]
        |       |   |   |--SEMI -> ; [171:34]
        |       |   |   `--RCURLY -> } [172:9]
        |       |   `--LITERAL_ELSE -> else [172:11]
        |       |       `--SLIST -> { [172:16]
        |       |           `--RCURLY -> } [173:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [175:9]
        |       |   |--MODIFIERS -> MODIFIERS [175:9]
        |       |   |--TYPE -> TYPE [175:9]
        |       |   |   `--LITERAL_INT -> int [175:9]
        |       |   |--IDENT -> x [175:13]
        |       |   `--ASSIGN -> = [175:15]
        |       |       `--EXPR -> EXPR [175:40]
        |       |           `--QUESTION -> ? [175:40]
        |       |               |--LITERAL_INSTANCEOF -> instanceof [175:20]
        |       |               |   |--IDENT -> o1 [175:17]
        |       |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [175:31]
        |       |               |       |--MODIFIERS -> MODIFIERS [175:31]
        |       |               |       |--TYPE -> TYPE [175:31]
        |       |               |       |   `--IDENT -> String [175:31]
        |       |               |       `--IDENT -> j [175:38]
        |       |               |--METHOD_CALL -> ( [175:50]
        |       |               |   |--DOT -> . [175:43]
        |       |               |   |   |--IDENT -> j [175:42]
        |       |               |   |   `--IDENT -> length [175:44]
        |       |               |   |--ELIST -> ELIST [175:51]
        |       |               |   `--RPAREN -> ) [175:51]
        |       |               |--COLON -> : [175:53]
        |       |               `--NUM_INT -> 2 [175:55]
        |       |--SEMI -> ; [175:56]
        |       |--EXPR -> EXPR [177:11]
        |       |   `--ASSIGN -> = [177:11]
        |       |       |--IDENT -> x [177:9]
        |       |       `--QUESTION -> ? [177:39]
        |       |           |--LNOT -> ! [177:13]
        |       |           |   |--LPAREN -> ( [177:14]
        |       |           |   |--LITERAL_INSTANCEOF -> instanceof [177:18]
        |       |           |   |   |--IDENT -> o1 [177:15]
        |       |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [177:29]
        |       |           |   |       |--MODIFIERS -> MODIFIERS [177:29]
        |       |           |   |       |--TYPE -> TYPE [177:29]
        |       |           |   |       |   `--IDENT -> String [177:29]
        |       |           |   |       `--IDENT -> j [177:36]
        |       |           |   `--RPAREN -> ) [177:37]
        |       |           |--NUM_INT -> 2 [177:41]
        |       |           |--COLON -> : [177:43]
        |       |           `--METHOD_CALL -> ( [177:53]
        |       |               |--DOT -> . [177:46]
        |       |               |   |--IDENT -> j [177:45]
        |       |               |   `--IDENT -> length [177:47]
        |       |               |--ELIST -> ELIST [177:54]
        |       |               `--RPAREN -> ) [177:54]
        |       |--SEMI -> ; [177:55]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [179:9]
        |       |   |--MODIFIERS -> MODIFIERS [179:9]
        |       |   |--TYPE -> TYPE [179:9]
        |       |   |   `--IDENT -> Object [179:9]
        |       |   |--IDENT -> ch [179:16]
        |       |   `--ASSIGN -> = [179:19]
        |       |       `--EXPR -> EXPR [179:21]
        |       |           `--LITERAL_NULL -> null [179:21]
        |       |--SEMI -> ; [179:25]
        |       |--LITERAL_FOR -> for [181:9]
        |       |   |--LPAREN -> ( [181:13]
        |       |   |--FOR_INIT -> FOR_INIT [181:14]
        |       |   |--SEMI -> ; [181:14]
        |       |   |--FOR_CONDITION -> FOR_CONDITION [181:19]
        |       |   |   `--EXPR -> EXPR [181:19]
        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [181:19]
        |       |   |           |--IDENT -> o1 [181:16]
        |       |   |           `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [181:30]
        |       |   |               |--MODIFIERS -> MODIFIERS [181:30]
        |       |   |               |--TYPE -> TYPE [181:30]
        |       |   |               |   `--IDENT -> String [181:30]
        |       |   |               `--IDENT -> j [181:37]
        |       |   |--SEMI -> ; [181:38]
        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [181:48]
        |       |   |   `--ELIST -> ELIST [181:48]
        |       |   |       `--EXPR -> EXPR [181:48]
        |       |   |           `--METHOD_CALL -> ( [181:48]
        |       |   |               |--DOT -> . [181:41]
        |       |   |               |   |--IDENT -> j [181:40]
        |       |   |               |   `--IDENT -> length [181:42]
        |       |   |               |--ELIST -> ELIST [181:49]
        |       |   |               `--RPAREN -> ) [181:49]
        |       |   |--RPAREN -> ) [181:50]
        |       |   `--SLIST -> { [181:52]
        |       |       |--EXPR -> EXPR [182:31]
        |       |       |   `--METHOD_CALL -> ( [182:31]
        |       |       |       |--DOT -> . [182:23]
        |       |       |       |   |--DOT -> . [182:19]
        |       |       |       |   |   |--IDENT -> System [182:13]
        |       |       |       |   |   `--IDENT -> out [182:20]
        |       |       |       |   `--IDENT -> println [182:24]
        |       |       |       |--ELIST -> ELIST [182:32]
        |       |       |       |   `--EXPR -> EXPR [182:32]
        |       |       |       |       `--IDENT -> j [182:32]
        |       |       |       `--RPAREN -> ) [182:33]
        |       |       |--SEMI -> ; [182:34]
        |       |       `--RCURLY -> } [183:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [185:9]
        |       |   |--MODIFIERS -> MODIFIERS [185:9]
        |       |   |--TYPE -> TYPE [185:9]
        |       |   |   `--IDENT -> String [185:9]
        |       |   `--IDENT -> formatted [185:16]
        |       |--SEMI -> ; [185:25]
        |       |--LITERAL_IF -> if [186:9]
        |       |   |--LPAREN -> ( [186:12]
        |       |   |--EXPR -> EXPR [186:16]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [186:16]
        |       |   |       |--IDENT -> o1 [186:13]
        |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [186:27]
        |       |   |           |--MODIFIERS -> MODIFIERS [186:27]
        |       |   |           |--TYPE -> TYPE [186:27]
        |       |   |           |   `--IDENT -> Integer [186:27]
        |       |   |           `--IDENT -> i [186:35]
        |       |   |--RPAREN -> ) [186:36]
        |       |   |--EXPR -> EXPR [186:48]
        |       |   |   `--ASSIGN -> = [186:48]
        |       |   |       |--IDENT -> formatted [186:38]
        |       |   |       `--METHOD_CALL -> ( [186:63]
        |       |   |           |--DOT -> . [186:56]
        |       |   |           |   |--IDENT -> String [186:50]
        |       |   |           |   `--IDENT -> format [186:57]
        |       |   |           |--ELIST -> ELIST [186:64]
        |       |   |           |   |--EXPR -> EXPR [186:64]
        |       |   |           |   |   `--STRING_LITERAL -> "int %d" [186:64]
        |       |   |           |   |--COMMA -> , [186:72]
        |       |   |           |   `--EXPR -> EXPR [186:74]
        |       |   |           |       `--IDENT -> i [186:74]
        |       |   |           `--RPAREN -> ) [186:75]
        |       |   |--SEMI -> ; [186:76]
        |       |   `--LITERAL_ELSE -> else [187:9]
        |       |       `--LITERAL_IF -> if [187:14]
        |       |           |--LPAREN -> ( [187:17]
        |       |           |--EXPR -> EXPR [187:21]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [187:21]
        |       |           |       |--IDENT -> o1 [187:18]
        |       |           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [187:32]
        |       |           |           |--MODIFIERS -> MODIFIERS [187:32]
        |       |           |           |--TYPE -> TYPE [187:32]
        |       |           |           |   `--IDENT -> Byte [187:32]
        |       |           |           `--IDENT -> by [187:37]
        |       |           |--RPAREN -> ) [187:39]
        |       |           |--EXPR -> EXPR [187:51]
        |       |           |   `--ASSIGN -> = [187:51]
        |       |           |       |--IDENT -> formatted [187:41]
        |       |           |       `--METHOD_CALL -> ( [187:66]
        |       |           |           |--DOT -> . [187:59]
        |       |           |           |   |--IDENT -> String [187:53]
        |       |           |           |   `--IDENT -> format [187:60]
        |       |           |           |--ELIST -> ELIST [187:67]
        |       |           |           |   |--EXPR -> EXPR [187:67]
        |       |           |           |   |   `--STRING_LITERAL -> "byte %d" [187:67]
        |       |           |           |   |--COMMA -> , [187:76]
        |       |           |           |   `--EXPR -> EXPR [187:78]
        |       |           |           |       `--IDENT -> by [187:78]
        |       |           |           `--RPAREN -> ) [187:80]
        |       |           |--SEMI -> ; [187:81]
        |       |           `--LITERAL_ELSE -> else [188:9]
        |       |               `--LITERAL_IF -> if [188:14]
        |       |                   |--LPAREN -> ( [188:17]
        |       |                   |--EXPR -> EXPR [188:21]
        |       |                   |   `--LITERAL_INSTANCEOF -> instanceof [188:21]
        |       |                   |       |--IDENT -> o1 [188:18]
        |       |                   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [188:32]
        |       |                   |           |--MODIFIERS -> MODIFIERS [188:32]
        |       |                   |           |--TYPE -> TYPE [188:32]
        |       |                   |           |   `--IDENT -> Long [188:32]
        |       |                   |           `--IDENT -> l [188:37]
        |       |                   |--RPAREN -> ) [188:38]
        |       |                   |--EXPR -> EXPR [188:50]
        |       |                   |   `--ASSIGN -> = [188:50]
        |       |                   |       |--IDENT -> formatted [188:40]
        |       |                   |       `--METHOD_CALL -> ( [188:65]
        |       |                   |           |--DOT -> . [188:58]
        |       |                   |           |   |--IDENT -> String [188:52]
        |       |                   |           |   `--IDENT -> format [188:59]
        |       |                   |           |--ELIST -> ELIST [188:66]
        |       |                   |           |   |--EXPR -> EXPR [188:66]
        |       |                   |           |   |   `--STRING_LITERAL -> "long %d" [188:66]
        |       |                   |           |   |--COMMA -> , [188:75]
        |       |                   |           |   `--EXPR -> EXPR [188:77]
        |       |                   |           |       `--IDENT -> l [188:77]
        |       |                   |           `--RPAREN -> ) [188:78]
        |       |                   |--SEMI -> ; [188:79]
        |       |                   `--LITERAL_ELSE -> else [189:9]
        |       |                       `--LITERAL_IF -> if [189:14]
        |       |                           |--LPAREN -> ( [189:17]
        |       |                           |--EXPR -> EXPR [189:21]
        |       |                           |   `--LITERAL_INSTANCEOF -> instanceof [189:21]
        |       |                           |       |--IDENT -> o1 [189:18]
        |       |                           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [189:32]
        |       |                           |           |--MODIFIERS -> MODIFIERS [189:32]
        |       |                           |           |--TYPE -> TYPE [189:32]
        |       |                           |           |   `--IDENT -> Double [189:32]
        |       |                           |           `--IDENT -> d [189:39]
        |       |                           |--RPAREN -> ) [189:40]
        |       |                           |--EXPR -> EXPR [189:52]
        |       |                           |   `--ASSIGN -> = [189:52]
        |       |                           |       |--IDENT -> formatted [189:42]
        |       |                           |       `--METHOD_CALL -> ( [189:67]
        |       |                           |           |--DOT -> . [189:60]
        |       |                           |           |   |--IDENT -> String [189:54]
        |       |                           |           |   `--IDENT -> format [189:61]
        |       |                           |           |--ELIST -> ELIST [189:68]
        |       |                           |           |   |--EXPR -> EXPR [189:68]
        |       |                           |           |   |   `--STRING_LITERAL -> "double %f" [189:68]
        |       |                           |           |   |--COMMA -> , [189:79]
        |       |                           |           |   `--EXPR -> EXPR [189:81]
        |       |                           |           |       `--IDENT -> d [189:81]
        |       |                           |           `--RPAREN -> ) [189:82]
        |       |                           |--SEMI -> ; [189:83]
        |       |                           `--LITERAL_ELSE -> else [190:9]
        |       |                               `--LITERAL_IF -> if [190:14]
        |       |                                   |--LPAREN -> ( [190:17]
        |       |                                   |--EXPR -> EXPR [190:21]
        |       |                                   |   `--LITERAL_INSTANCEOF -> instanceof [190:21]
        |       |                                   |       |--IDENT -> o1 [190:18]
        |       |                                   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [190:32]
        |       |                                   |           |--MODIFIERS -> MODIFIERS [190:32]
        |       |                                   |           |--TYPE -> TYPE [190:32]
        |       |                                   |           |   `--IDENT -> String [190:32]
        |       |                                   |           `--IDENT -> s [190:39]
        |       |                                   |--RPAREN -> ) [190:40]
        |       |                                   |--EXPR -> EXPR [190:52]
        |       |                                   |   `--ASSIGN -> = [190:52]
        |       |                                   |       |--IDENT -> formatted [190:42]
        |       |                                   |       `--METHOD_CALL -> ( [190:67]
        |       |                                   |           |--DOT -> . [190:60]
        |       |                                   |           |   |--IDENT -> String [190:54]
        |       |                                   |           |   `--IDENT -> format [190:61]
        |       |                                   |           |--ELIST -> ELIST [190:68]
        |       |                                   |           |   |--EXPR -> EXPR [190:68]
        |       |                                   |           |   |   `--STRING_LITERAL -> "String %s" [190:68]
        |       |                                   |           |   |--COMMA -> , [190:79]
        |       |                                   |           |   `--EXPR -> EXPR [190:81]
        |       |                                   |           |       `--IDENT -> s [190:81]
        |       |                                   |           `--RPAREN -> ) [190:82]
        |       |                                   |--SEMI -> ; [190:83]
        |       |                                   `--LITERAL_ELSE -> else [191:9]
        |       |                                       |--EXPR -> EXPR [191:24]
        |       |                                       |   `--ASSIGN -> = [191:24]
        |       |                                       |       |--IDENT -> formatted [191:14]
        |       |                                       |       `--METHOD_CALL -> ( [191:39]
        |       |                                       |           |--DOT -> . [191:32]
        |       |                                       |           |   |--IDENT -> String [191:26]
        |       |                                       |           |   `--IDENT -> format [191:33]
        |       |                                       |           |--ELIST -> ELIST [191:57]
        |       |                                       |           |   `--EXPR -> EXPR [191:57]
        |       |                                       |           |       `--PLUS -> + [191:57]
        |       |                                       |           |           |--STRING_LITERAL -> "Something else " [191:40]
        |       |                                       |           |           `--METHOD_CALL -> ( [191:70]
        |       |                                       |           |               |--DOT -> . [191:61]
        |       |                                       |           |               |   |--IDENT -> o1 [191:59]
        |       |                                       |           |               |   `--IDENT -> toString [191:62]
        |       |                                       |           |               |--ELIST -> ELIST [191:71]
        |       |                                       |           |               `--RPAREN -> ) [191:71]
        |       |                                       |           `--RPAREN -> ) [191:72]
        |       |                                       `--SEMI -> ; [191:73]
        |       |--LITERAL_DO -> do [193:9]
        |       |   |--SLIST -> { [193:12]
        |       |   |   |--LABELED_STAT -> : [194:15]
        |       |   |   |   |--IDENT -> L4 [194:13]
        |       |   |   |   `--LITERAL_BREAK -> break [194:17]
        |       |   |   |       |--IDENT -> L4 [194:23]
        |       |   |   |       `--SEMI -> ; [194:25]
        |       |   |   `--RCURLY -> } [195:9]
        |       |   |--DO_WHILE -> while [195:11]
        |       |   |--LPAREN -> ( [195:17]
        |       |   |--EXPR -> EXPR [195:18]
        |       |   |   `--LNOT -> ! [195:18]
        |       |   |       |--LPAREN -> ( [195:19]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [195:23]
        |       |   |       |   |--IDENT -> o1 [195:20]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [195:34]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [195:34]
        |       |   |       |       |--TYPE -> TYPE [195:34]
        |       |   |       |       |   `--IDENT -> String [195:34]
        |       |   |       |       `--IDENT -> s [195:41]
        |       |   |       `--RPAREN -> ) [195:42]
        |       |   |--RPAREN -> ) [195:43]
        |       |   `--SEMI -> ; [195:44]
        |       |--LITERAL_DO -> do [197:9]
        |       |   |--SLIST -> { [197:12]
        |       |   |   |--LABELED_STAT -> : [198:15]
        |       |   |   |   |--IDENT -> L4 [198:13]
        |       |   |   |   `--LITERAL_BREAK -> break [198:17]
        |       |   |   |       |--IDENT -> L4 [198:23]
        |       |   |   |       `--SEMI -> ; [198:25]
        |       |   |   `--RCURLY -> } [199:9]
        |       |   |--DO_WHILE -> while [199:11]
        |       |   |--LPAREN -> ( [199:17]
        |       |   |--EXPR -> EXPR [199:18]
        |       |   |   `--LNOT -> ! [199:18]
        |       |   |       |--LPAREN -> ( [199:19]
        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [199:23]
        |       |   |       |   |--IDENT -> o1 [199:20]
        |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [199:43]
        |       |   |       |       |--MODIFIERS -> MODIFIERS [199:43]
        |       |   |       |       |--TYPE -> TYPE [199:43]
        |       |   |       |       |   `--DOT -> . [199:43]
        |       |   |       |       |       |--DOT -> . [199:38]
        |       |   |       |       |       |   |--IDENT -> java [199:34]
        |       |   |       |       |       |   `--IDENT -> lang [199:39]
        |       |   |       |       |       `--IDENT -> Double [199:44]
        |       |   |       |       `--IDENT -> log [199:51]
        |       |   |       `--RPAREN -> ) [199:54]
        |       |   |--RPAREN -> ) [199:55]
        |       |   `--SEMI -> ; [199:56]
        |       `--RCURLY -> } [200:5]
        |--CLASS_DEF -> CLASS_DEF [202:5]
        |   |--MODIFIERS -> MODIFIERS [202:5]
        |   |   `--LITERAL_STATIC -> static [202:5]
        |   |--LITERAL_CLASS -> class [202:12]
        |   |--IDENT -> Pattern_Simple [202:18]
        |   `--OBJBLOCK -> OBJBLOCK [202:33]
        |       |--LCURLY -> { [202:33]
        |       |--METHOD_DEF -> METHOD_DEF [203:9]
        |       |   |--MODIFIERS -> MODIFIERS [203:9]
        |       |   |   |--LITERAL_PUBLIC -> public [203:9]
        |       |   |   `--LITERAL_STATIC -> static [203:16]
        |       |   |--TYPE -> TYPE [203:23]
        |       |   |   `--LITERAL_VOID -> void [203:23]
        |       |   |--IDENT -> test [203:28]
        |       |   |--LPAREN -> ( [203:32]
        |       |   |--PARAMETERS -> PARAMETERS [203:33]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [203:33]
        |       |   |       |--MODIFIERS -> MODIFIERS [203:33]
        |       |   |       |--TYPE -> TYPE [203:33]
        |       |   |       |   `--IDENT -> Object [203:33]
        |       |   |       `--IDENT -> o [203:40]
        |       |   |--RPAREN -> ) [203:41]
        |       |   `--SLIST -> { [203:43]
        |       |       |--LITERAL_IF -> if [204:13]
        |       |       |   |--LPAREN -> ( [204:16]
        |       |       |   |--EXPR -> EXPR [204:19]
        |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [204:19]
        |       |       |   |       |--IDENT -> o [204:17]
        |       |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [204:30]
        |       |       |   |           |--MODIFIERS -> MODIFIERS [204:30]
        |       |       |   |           |--TYPE -> TYPE [204:30]
        |       |       |   |           |   `--IDENT -> String [204:30]
        |       |       |   |           `--IDENT -> s [204:37]
        |       |       |   |--RPAREN -> ) [204:38]
        |       |       |   `--SLIST -> { [204:40]
        |       |       |       `--RCURLY -> } [204:41]
        |       |       `--RCURLY -> } [205:9]
        |       `--RCURLY -> } [206:5]
        |--CLASS_DEF -> CLASS_DEF [208:5]
        |   |--MODIFIERS -> MODIFIERS [208:5]
        |   |   `--LITERAL_STATIC -> static [208:5]
        |   |--LITERAL_CLASS -> class [208:12]
        |   |--IDENT -> Pattern_Lambda [208:18]
        |   `--OBJBLOCK -> OBJBLOCK [208:33]
        |       |--LCURLY -> { [208:33]
        |       |--METHOD_DEF -> METHOD_DEF [209:9]
        |       |   |--MODIFIERS -> MODIFIERS [209:9]
        |       |   |   |--LITERAL_PUBLIC -> public [209:9]
        |       |   |   `--LITERAL_STATIC -> static [209:16]
        |       |   |--TYPE -> TYPE [209:23]
        |       |   |   `--LITERAL_VOID -> void [209:23]
        |       |   |--IDENT -> test [209:28]
        |       |   |--LPAREN -> ( [209:32]
        |       |   |--PARAMETERS -> PARAMETERS [209:33]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [209:33]
        |       |   |       |--MODIFIERS -> MODIFIERS [209:33]
        |       |   |       |--TYPE -> TYPE [209:33]
        |       |   |       |   `--IDENT -> Object [209:33]
        |       |   |       `--IDENT -> o [209:40]
        |       |   |--RPAREN -> ) [209:41]
        |       |   `--SLIST -> { [209:43]
        |       |       |--LITERAL_IF -> if [210:13]
        |       |       |   |--LPAREN -> ( [210:16]
        |       |       |   |--EXPR -> EXPR [210:19]
        |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [210:19]
        |       |       |   |       |--IDENT -> o [210:17]
        |       |       |   |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [210:30]
        |       |       |   |           |--MODIFIERS -> MODIFIERS [210:30]
        |       |       |   |           |--TYPE -> TYPE [210:30]
        |       |       |   |           |   `--IDENT -> String [210:30]
        |       |       |   |           `--IDENT -> s [210:37]
        |       |       |   |--RPAREN -> ) [210:38]
        |       |       |   `--SLIST -> { [210:40]
        |       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [211:17]
        |       |       |       |   |--MODIFIERS -> MODIFIERS [211:17]
        |       |       |       |   |--TYPE -> TYPE [211:17]
        |       |       |       |   |   `--IDENT -> Runnable [211:17]
        |       |       |       |   |--IDENT -> r [211:26]
        |       |       |       |   `--ASSIGN -> = [211:28]
        |       |       |       |       `--LAMBDA -> -> [211:33]
        |       |       |       |           |--LPAREN -> ( [211:30]
        |       |       |       |           |--PARAMETERS -> PARAMETERS [211:31]
        |       |       |       |           |--RPAREN -> ) [211:31]
        |       |       |       |           `--SLIST -> { [211:36]
        |       |       |       |               |--EXPR -> EXPR [212:29]
        |       |       |       |               |   `--METHOD_CALL -> ( [212:29]
        |       |       |       |               |       |--DOT -> . [212:22]
        |       |       |       |               |       |   |--IDENT -> s [212:21]
        |       |       |       |               |       |   `--IDENT -> length [212:23]
        |       |       |       |               |       |--ELIST -> ELIST [212:30]
        |       |       |       |               |       `--RPAREN -> ) [212:30]
        |       |       |       |               |--SEMI -> ; [212:31]
        |       |       |       |               `--RCURLY -> } [213:17]
        |       |       |       |--SEMI -> ; [213:18]
        |       |       |       `--RCURLY -> } [214:13]
        |       |       `--RCURLY -> } [215:9]
        |       `--RCURLY -> } [216:5]
        `--RCURLY -> } [217:1]
