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