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]