COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:48]
|   |--DOT -> . [2:48]
|   |   |--DOT -> . [2:40]
|   |   |   |--DOT -> . [2:29]
|   |   |   |   |--DOT -> . [2:23]
|   |   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   |   `--IDENT -> tools [2:24]
|   |   |   |   `--IDENT -> checkstyle [2:30]
|   |   |   `--IDENT -> grammar [2:41]
|   |   `--IDENT -> java19 [2:49]
|   `--SEMI -> ; [2:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputJava19BindingWithModifiers [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:46]
        |--LCURLY -> { [4:46]
        |--RECORD_DEF -> RECORD_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |--LITERAL_RECORD -> record [5:5]
        |   |--IDENT -> Box [5:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [5:15]
        |   |   |--GENERIC_START -> < [5:15]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [5:16]
        |   |   |   `--IDENT -> T [5:16]
        |   |   `--GENERIC_END -> > [5:17]
        |   |--LPAREN -> ( [5:18]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [5:19]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [5:19]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [5:19]
        |   |       |--TYPE -> TYPE [5:19]
        |   |       |   `--IDENT -> T [5:19]
        |   |       `--IDENT -> t [5:21]
        |   |--RPAREN -> ) [5:22]
        |   `--OBJBLOCK -> OBJBLOCK [5:24]
        |       |--LCURLY -> { [5:24]
        |       `--RCURLY -> } [6:5]
        |--CLASS_DEF -> CLASS_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |--LITERAL_CLASS -> class [8:5]
        |   |--IDENT -> A [8:11]
        |   `--OBJBLOCK -> OBJBLOCK [8:13]
        |       |--LCURLY -> { [8:13]
        |       `--RCURLY -> } [9:5]
        |--CLASS_DEF -> CLASS_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |--LITERAL_CLASS -> class [11:5]
        |   |--IDENT -> B [11:11]
        |   |--EXTENDS_CLAUSE -> extends [11:13]
        |   |   `--IDENT -> A [11:21]
        |   `--OBJBLOCK -> OBJBLOCK [11:23]
        |       |--LCURLY -> { [11:23]
        |       `--RCURLY -> } [12:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [14:5]
        |   |--MODIFIERS -> MODIFIERS [14:5]
        |   |   `--LITERAL_SEALED -> sealed [14:5]
        |   |--LITERAL_INTERFACE -> interface [14:12]
        |   |--IDENT -> I [14:22]
        |   |--PERMITS_CLAUSE -> permits [14:24]
        |   |   |--IDENT -> C [14:32]
        |   |   |--COMMA -> , [14:33]
        |   |   `--IDENT -> D [14:35]
        |   `--OBJBLOCK -> OBJBLOCK [14:37]
        |       |--LCURLY -> { [14:37]
        |       `--RCURLY -> } [15:5]
        |--CLASS_DEF -> CLASS_DEF [17:5]
        |   |--MODIFIERS -> MODIFIERS [17:5]
        |   |   `--FINAL -> final [17:5]
        |   |--LITERAL_CLASS -> class [17:11]
        |   |--IDENT -> C [17:17]
        |   |--IMPLEMENTS_CLAUSE -> implements [17:19]
        |   |   `--IDENT -> I [17:30]
        |   `--OBJBLOCK -> OBJBLOCK [17:32]
        |       |--LCURLY -> { [17:32]
        |       `--RCURLY -> } [18:5]
        |--CLASS_DEF -> CLASS_DEF [20:5]
        |   |--MODIFIERS -> MODIFIERS [20:5]
        |   |   `--FINAL -> final [20:5]
        |   |--LITERAL_CLASS -> class [20:11]
        |   |--IDENT -> D [20:17]
        |   |--IMPLEMENTS_CLAUSE -> implements [20:19]
        |   |   `--IDENT -> I [20:30]
        |   `--OBJBLOCK -> OBJBLOCK [20:32]
        |       |--LCURLY -> { [20:32]
        |       `--RCURLY -> } [21:5]
        |--RECORD_DEF -> RECORD_DEF [23:5]
        |   |--MODIFIERS -> MODIFIERS [23:5]
        |   |--LITERAL_RECORD -> record [23:5]
        |   |--IDENT -> Pair [23:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [23:16]
        |   |   |--GENERIC_START -> < [23:16]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:17]
        |   |   |   `--IDENT -> T [23:17]
        |   |   `--GENERIC_END -> > [23:18]
        |   |--LPAREN -> ( [23:19]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [23:20]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:20]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [23:20]
        |   |   |   |--TYPE -> TYPE [23:20]
        |   |   |   |   `--IDENT -> T [23:20]
        |   |   |   `--IDENT -> x [23:22]
        |   |   |--COMMA -> , [23:23]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:25]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [23:25]
        |   |       |--TYPE -> TYPE [23:25]
        |   |       |   `--IDENT -> T [23:25]
        |   |       `--IDENT -> y [23:27]
        |   |--RPAREN -> ) [23:28]
        |   `--OBJBLOCK -> OBJBLOCK [23:30]
        |       |--LCURLY -> { [23:30]
        |       `--RCURLY -> } [24:5]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [26:5]
        |   |--MODIFIERS -> MODIFIERS [26:5]
        |   |--AT -> @ [26:5]
        |   |--LITERAL_INTERFACE -> interface [26:6]
        |   |--IDENT -> MyAnno1 [26:16]
        |   `--OBJBLOCK -> OBJBLOCK [26:23]
        |       |--LCURLY -> { [26:23]
        |       `--RCURLY -> } [26:24]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [27:5]
        |   |--MODIFIERS -> MODIFIERS [27:5]
        |   |--AT -> @ [27:5]
        |   |--LITERAL_INTERFACE -> interface [27:6]
        |   |--IDENT -> MyAnno2 [27:16]
        |   `--OBJBLOCK -> OBJBLOCK [27:23]
        |       |--LCURLY -> { [27:23]
        |       `--RCURLY -> } [27:24]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [29:5]
        |   |--MODIFIERS -> MODIFIERS [29:5]
        |   |--AT -> @ [29:5]
        |   |--LITERAL_INTERFACE -> interface [29:6]
        |   |--IDENT -> MyAnno3 [29:16]
        |   `--OBJBLOCK -> OBJBLOCK [29:23]
        |       |--LCURLY -> { [29:23]
        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [30:9]
        |       |   |--MODIFIERS -> MODIFIERS [30:9]
        |       |   |--TYPE -> TYPE [30:9]
        |       |   |   `--IDENT -> String [30:9]
        |       |   |--IDENT -> value [30:16]
        |       |   |--LPAREN -> ( [30:21]
        |       |   |--RPAREN -> ) [30:22]
        |       |   `--SEMI -> ; [30:23]
        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [31:9]
        |       |   |--MODIFIERS -> MODIFIERS [31:9]
        |       |   |--TYPE -> TYPE [31:9]
        |       |   |   |--IDENT -> String [31:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [31:15]
        |       |   |       `--RBRACK -> ] [31:16]
        |       |   |--IDENT -> values [31:18]
        |       |   |--LPAREN -> ( [31:24]
        |       |   |--RPAREN -> ) [31:25]
        |       |   `--SEMI -> ; [31:26]
        |       `--RCURLY -> } [32:5]
        |--RECORD_DEF -> RECORD_DEF [34:5]
        |   |--MODIFIERS -> MODIFIERS [34:5]
        |   |--LITERAL_RECORD -> record [34:5]
        |   |--IDENT -> Tuple [34:12]
        |   |--LPAREN -> ( [34:17]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [34:18]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:18]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [34:18]
        |   |   |   |--TYPE -> TYPE [34:18]
        |   |   |   |   `--IDENT -> Object [34:18]
        |   |   |   `--IDENT -> o1 [34:25]
        |   |   |--COMMA -> , [34:27]
        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:29]
        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [34:29]
        |   |   |   |--TYPE -> TYPE [34:29]
        |   |   |   |   `--IDENT -> Object [34:29]
        |   |   |   `--IDENT -> o2 [34:36]
        |   |   |--COMMA -> , [34:38]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:40]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [34:40]
        |   |       |--TYPE -> TYPE [34:40]
        |   |       |   `--IDENT -> Object [34:40]
        |   |       `--IDENT -> o3 [34:47]
        |   |--RPAREN -> ) [34:49]
        |   `--OBJBLOCK -> OBJBLOCK [34:51]
        |       |--LCURLY -> { [34:51]
        |       `--RCURLY -> } [34:52]
        |--RECORD_DEF -> RECORD_DEF [35:5]
        |   |--MODIFIERS -> MODIFIERS [35:5]
        |   |--LITERAL_RECORD -> record [35:5]
        |   |--IDENT -> VarArgs [35:12]
        |   |--LPAREN -> ( [35:19]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [35:20]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [35:20]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [35:20]
        |   |       |--TYPE -> TYPE [35:20]
        |   |       |   `--IDENT -> Object [35:20]
        |   |       |--ELLIPSIS -> ... [35:26]
        |   |       `--IDENT -> objArgs [35:30]
        |   |--RPAREN -> ) [35:37]
        |   `--OBJBLOCK -> OBJBLOCK [35:38]
        |       |--LCURLY -> { [35:38]
        |       `--RCURLY -> } [35:39]
        |--METHOD_DEF -> METHOD_DEF [38:5]
        |   |--MODIFIERS -> MODIFIERS [38:5]
        |   |   `--LITERAL_STATIC -> static [38:5]
        |   |--TYPE -> TYPE [38:12]
        |   |   `--LITERAL_VOID -> void [38:12]
        |   |--IDENT -> test1 [38:17]
        |   |--LPAREN -> ( [38:22]
        |   |--PARAMETERS -> PARAMETERS [38:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:23]
        |   |       |--MODIFIERS -> MODIFIERS [38:23]
        |   |       |--TYPE -> TYPE [38:23]
        |   |       |   |--IDENT -> Box [38:23]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:26]
        |   |       |       |--GENERIC_START -> < [38:26]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:27]
        |   |       |       |   `--IDENT -> Object [38:27]
        |   |       |       `--GENERIC_END -> > [38:33]
        |   |       `--IDENT -> bo [38:35]
        |   |--RPAREN -> ) [38:37]
        |   `--SLIST -> { [38:39]
        |       |--LITERAL_IF -> if [39:9]
        |       |   |--LPAREN -> ( [39:12]
        |       |   |--EXPR -> EXPR [39:16]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [39:16]
        |       |   |       |--IDENT -> bo [39:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [39:27]
        |       |   |           |--MODIFIERS -> MODIFIERS [39:27]
        |       |   |           |   |--ANNOTATION -> ANNOTATION [39:27]
        |       |   |           |   |   |--AT -> @ [39:27]
        |       |   |           |   |   `--IDENT -> MyAnno1 [39:28]
        |       |   |           |   `--ANNOTATION -> ANNOTATION [39:36]
        |       |   |           |       |--AT -> @ [39:36]
        |       |   |           |       `--IDENT -> MyAnno2 [39:37]
        |       |   |           |--TYPE -> TYPE [39:45]
        |       |   |           |   |--IDENT -> Box [39:45]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:48]
        |       |   |           |       |--GENERIC_START -> < [39:48]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:49]
        |       |   |           |       |   `--IDENT -> Object [39:49]
        |       |   |           |       `--GENERIC_END -> > [39:55]
        |       |   |           |--LPAREN -> ( [39:56]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [39:57]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:57]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [39:57]
        |       |   |           |       |--TYPE -> TYPE [39:57]
        |       |   |           |       |   `--IDENT -> String [39:57]
        |       |   |           |       `--IDENT -> s [39:64]
        |       |   |           `--RPAREN -> ) [39:65]
        |       |   |--RPAREN -> ) [39:66]
        |       |   `--SLIST -> { [39:68]
        |       |       |--EXPR -> EXPR [40:31]
        |       |       |   `--METHOD_CALL -> ( [40:31]
        |       |       |       |--DOT -> . [40:23]
        |       |       |       |   |--DOT -> . [40:19]
        |       |       |       |   |   |--IDENT -> System [40:13]
        |       |       |       |   |   `--IDENT -> out [40:20]
        |       |       |       |   `--IDENT -> println [40:24]
        |       |       |       |--ELIST -> ELIST [40:42]
        |       |       |       |   `--EXPR -> EXPR [40:42]
        |       |       |       |       `--PLUS -> + [40:42]
        |       |       |       |           |--STRING_LITERAL -> "String " [40:32]
        |       |       |       |           `--IDENT -> s [40:44]
        |       |       |       `--RPAREN -> ) [40:45]
        |       |       |--SEMI -> ; [40:46]
        |       |       `--RCURLY -> } [41:9]
        |       `--RCURLY -> } [42:5]
        |--METHOD_DEF -> METHOD_DEF [44:5]
        |   |--MODIFIERS -> MODIFIERS [44:5]
        |   |   `--LITERAL_STATIC -> static [44:5]
        |   |--TYPE -> TYPE [44:12]
        |   |   `--LITERAL_VOID -> void [44:12]
        |   |--IDENT -> test2 [44:17]
        |   |--LPAREN -> ( [44:22]
        |   |--PARAMETERS -> PARAMETERS [44:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [44:23]
        |   |       |--MODIFIERS -> MODIFIERS [44:23]
        |   |       |--TYPE -> TYPE [44:23]
        |   |       |   |--IDENT -> Box [44:23]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:26]
        |   |       |       |--GENERIC_START -> < [44:26]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:27]
        |   |       |       |   `--IDENT -> Object [44:27]
        |   |       |       `--GENERIC_END -> > [44:33]
        |   |       `--IDENT -> bo [44:35]
        |   |--RPAREN -> ) [44:37]
        |   `--SLIST -> { [44:39]
        |       |--LITERAL_IF -> if [45:9]
        |       |   |--LPAREN -> ( [45:12]
        |       |   |--EXPR -> EXPR [45:16]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [45:16]
        |       |   |       |--IDENT -> bo [45:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:27]
        |       |   |           |--MODIFIERS -> MODIFIERS [45:27]
        |       |   |           |   |--ANNOTATION -> ANNOTATION [45:27]
        |       |   |           |   |   |--AT -> @ [45:27]
        |       |   |           |   |   `--IDENT -> MyAnno2 [45:28]
        |       |   |           |   |--FINAL -> final [45:36]
        |       |   |           |   `--ANNOTATION -> ANNOTATION [45:42]
        |       |   |           |       |--AT -> @ [45:42]
        |       |   |           |       `--IDENT -> MyAnno1 [45:43]
        |       |   |           |--TYPE -> TYPE [45:51]
        |       |   |           |   |--IDENT -> Box [45:51]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:54]
        |       |   |           |       |--GENERIC_START -> < [45:54]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:55]
        |       |   |           |       |   `--WILDCARD_TYPE -> ? [45:55]
        |       |   |           |       `--GENERIC_END -> > [45:56]
        |       |   |           |--LPAREN -> ( [45:57]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [45:58]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:58]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [45:58]
        |       |   |           |       |--TYPE -> TYPE [45:58]
        |       |   |           |       |   `--IDENT -> var [45:58]
        |       |   |           |       `--IDENT -> s [45:62]
        |       |   |           `--RPAREN -> ) [45:63]
        |       |   |--RPAREN -> ) [45:64]
        |       |   `--SLIST -> { [45:66]
        |       |       |--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:42]
        |       |       |       |   `--EXPR -> EXPR [46:42]
        |       |       |       |       `--PLUS -> + [46:42]
        |       |       |       |           |--STRING_LITERAL -> "String " [46:32]
        |       |       |       |           `--IDENT -> s [46:44]
        |       |       |       `--RPAREN -> ) [46:45]
        |       |       |--SEMI -> ; [46:46]
        |       |       `--RCURLY -> } [47:9]
        |       `--RCURLY -> } [48:5]
        |--METHOD_DEF -> METHOD_DEF [50:5]
        |   |--MODIFIERS -> MODIFIERS [50:5]
        |   |--TYPE -> TYPE [50:5]
        |   |   `--LITERAL_VOID -> void [50:5]
        |   |--IDENT -> test3 [50:10]
        |   |--LPAREN -> ( [50:15]
        |   |--PARAMETERS -> PARAMETERS [50:16]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [50:16]
        |   |       |--MODIFIERS -> MODIFIERS [50:16]
        |   |       |--TYPE -> TYPE [50:16]
        |   |       |   |--IDENT -> Box [50:16]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:19]
        |   |       |       |--GENERIC_START -> < [50:19]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:20]
        |   |       |       |   `--IDENT -> I [50:20]
        |   |       |       `--GENERIC_END -> > [50:21]
        |   |       `--IDENT -> bo [50:23]
        |   |--RPAREN -> ) [50:25]
        |   `--SLIST -> { [50:27]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [51:9]
        |       |   |--MODIFIERS -> MODIFIERS [51:9]
        |       |   |--TYPE -> TYPE [51:9]
        |       |   |   `--IDENT -> C [51:9]
        |       |   |--IDENT -> c [51:11]
        |       |   `--ASSIGN -> = [51:13]
        |       |       `--EXPR -> EXPR [51:15]
        |       |           `--LITERAL_NEW -> new [51:15]
        |       |               |--IDENT -> C [51:19]
        |       |               |--LPAREN -> ( [51:20]
        |       |               |--ELIST -> ELIST [51:21]
        |       |               `--RPAREN -> ) [51:21]
        |       |--SEMI -> ; [51:22]
        |       |--LITERAL_IF -> if [52:9]
        |       |   |--LPAREN -> ( [52:12]
        |       |   |--EXPR -> EXPR [52:16]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [52:16]
        |       |   |       |--IDENT -> bo [52:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [52:27]
        |       |   |           |--MODIFIERS -> MODIFIERS [52:27]
        |       |   |           |   `--ANNOTATION -> ANNOTATION [52:27]
        |       |   |           |       |--AT -> @ [52:27]
        |       |   |           |       `--IDENT -> MyAnno1 [52:28]
        |       |   |           |--TYPE -> TYPE [52:36]
        |       |   |           |   |--IDENT -> Box [52:36]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [52:39]
        |       |   |           |       |--GENERIC_START -> < [52:39]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [52:40]
        |       |   |           |       |   `--IDENT -> I [52:40]
        |       |   |           |       `--GENERIC_END -> > [52:41]
        |       |   |           |--LPAREN -> ( [52:42]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [52:43]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:43]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [52:43]
        |       |   |           |       |--TYPE -> TYPE [52:43]
        |       |   |           |       |   `--IDENT -> var [52:43]
        |       |   |           |       `--IDENT -> s [52:47]
        |       |   |           `--RPAREN -> ) [52:48]
        |       |   |--RPAREN -> ) [52:49]
        |       |   |--SLIST -> { [52:51]
        |       |   |   |--EXPR -> EXPR [53:31]
        |       |   |   |   `--METHOD_CALL -> ( [53:31]
        |       |   |   |       |--DOT -> . [53:23]
        |       |   |   |       |   |--DOT -> . [53:19]
        |       |   |   |       |   |   |--IDENT -> System [53:13]
        |       |   |   |       |   |   `--IDENT -> out [53:20]
        |       |   |   |       |   `--IDENT -> println [53:24]
        |       |   |   |       |--ELIST -> ELIST [53:42]
        |       |   |   |       |   `--EXPR -> EXPR [53:42]
        |       |   |   |       |       `--PLUS -> + [53:42]
        |       |   |   |       |           |--STRING_LITERAL -> "String " [53:32]
        |       |   |   |       |           `--IDENT -> s [53:44]
        |       |   |   |       `--RPAREN -> ) [53:45]
        |       |   |   |--SEMI -> ; [53:46]
        |       |   |   `--RCURLY -> } [54:9]
        |       |   `--LITERAL_ELSE -> else [55:9]
        |       |       `--LITERAL_IF -> if [55:14]
        |       |           |--LPAREN -> ( [55:17]
        |       |           |--EXPR -> EXPR [55:21]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [55:21]
        |       |           |       |--IDENT -> bo [55:18]
        |       |           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [55:32]
        |       |           |           |--MODIFIERS -> MODIFIERS [55:32]
        |       |           |           |--TYPE -> TYPE [55:32]
        |       |           |           |   `--IDENT -> Box [55:32]
        |       |           |           `--IDENT -> b [55:36]
        |       |           |--RPAREN -> ) [55:37]
        |       |           |--SLIST -> { [55:39]
        |       |           |   `--RCURLY -> } [57:9]
        |       |           `--LITERAL_ELSE -> else [58:9]
        |       |               `--LITERAL_IF -> if [58:14]
        |       |                   |--LPAREN -> ( [58:17]
        |       |                   |--EXPR -> EXPR [58:41]
        |       |                   |   `--LAND -> && [58:41]
        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [58:21]
        |       |                   |       |   |--IDENT -> bo [58:18]
        |       |                   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [58:32]
        |       |                   |       |       |--MODIFIERS -> MODIFIERS [58:32]
        |       |                   |       |       |--TYPE -> TYPE [58:32]
        |       |                   |       |       |   |--IDENT -> Box [58:32]
        |       |                   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:35]
        |       |                   |       |       |       |--GENERIC_START -> < [58:35]
        |       |                   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:36]
        |       |                   |       |       |       |   `--IDENT -> I [58:36]
        |       |                   |       |       |       `--GENERIC_END -> > [58:37]
        |       |                   |       |       `--IDENT -> b [58:39]
        |       |                   |       `--METHOD_CALL -> ( [58:55]
        |       |                   |           |--DOT -> . [58:48]
        |       |                   |           |   |--DOT -> . [58:46]
        |       |                   |           |   |   |--IDENT -> bo [58:44]
        |       |                   |           |   |   `--IDENT -> t [58:47]
        |       |                   |           |   `--IDENT -> equals [58:49]
        |       |                   |           |--ELIST -> ELIST [58:56]
        |       |                   |           |   `--EXPR -> EXPR [58:56]
        |       |                   |           |       `--IDENT -> c [58:56]
        |       |                   |           `--RPAREN -> ) [58:57]
        |       |                   |--RPAREN -> ) [58:58]
        |       |                   |--SLIST -> { [58:60]
        |       |                   |   `--RCURLY -> } [60:9]
        |       |                   `--LITERAL_ELSE -> else [61:9]
        |       |                       `--LITERAL_IF -> if [61:14]
        |       |                           |--LPAREN -> ( [61:17]
        |       |                           |--EXPR -> EXPR [61:29]
        |       |                           |   `--LAND -> && [61:29]
        |       |                           |       |--NOT_EQUAL -> != [61:21]
        |       |                           |       |   |--IDENT -> bo [61:18]
        |       |                           |       |   `--LITERAL_NULL -> null [61:24]
        |       |                           |       `--METHOD_CALL -> ( [61:43]
        |       |                           |           |--DOT -> . [61:36]
        |       |                           |           |   |--DOT -> . [61:34]
        |       |                           |           |   |   |--IDENT -> bo [61:32]
        |       |                           |           |   |   `--IDENT -> t [61:35]
        |       |                           |           |   `--IDENT -> equals [61:37]
        |       |                           |           |--ELIST -> ELIST [61:44]
        |       |                           |           |   `--EXPR -> EXPR [61:44]
        |       |                           |           |       `--IDENT -> c [61:44]
        |       |                           |           `--RPAREN -> ) [61:45]
        |       |                           |--RPAREN -> ) [61:46]
        |       |                           `--SLIST -> { [61:48]
        |       |                               `--RCURLY -> } [63:9]
        |       `--RCURLY -> } [64:5]
        |--METHOD_DEF -> METHOD_DEF [66:5]
        |   |--MODIFIERS -> MODIFIERS [66:5]
        |   |   `--LITERAL_STATIC -> static [66:5]
        |   |--TYPE -> TYPE [66:12]
        |   |   `--LITERAL_VOID -> void [66:12]
        |   |--IDENT -> test4 [66:17]
        |   |--LPAREN -> ( [66:22]
        |   |--PARAMETERS -> PARAMETERS [66:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:23]
        |   |       |--MODIFIERS -> MODIFIERS [66:23]
        |   |       |--TYPE -> TYPE [66:23]
        |   |       |   |--IDENT -> Pair [66:23]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:27]
        |   |       |       |--GENERIC_START -> < [66:27]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:28]
        |   |       |       |   `--IDENT -> I [66:28]
        |   |       |       `--GENERIC_END -> > [66:29]
        |   |       `--IDENT -> p [66:31]
        |   |--RPAREN -> ) [66:32]
        |   `--SLIST -> { [66:34]
        |       |--LITERAL_IF -> if [67:9]
        |       |   |--LPAREN -> ( [67:12]
        |       |   |--EXPR -> EXPR [67:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [67:15]
        |       |   |       |--IDENT -> p [67:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [67:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [67:26]
        |       |   |           |   `--FINAL -> final [67:26]
        |       |   |           |--TYPE -> TYPE [67:32]
        |       |   |           |   |--IDENT -> Pair [67:32]
        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [67:36]
        |       |   |           |       |--GENERIC_START -> < [67:36]
        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [67:37]
        |       |   |           |       |   `--IDENT -> I [67:37]
        |       |   |           |       `--GENERIC_END -> > [67:38]
        |       |   |           |--LPAREN -> ( [67:39]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [67:40]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:40]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [67:40]
        |       |   |           |   |   |--TYPE -> TYPE [67:40]
        |       |   |           |   |   |   `--IDENT -> C [67:40]
        |       |   |           |   |   `--IDENT -> t1 [67:42]
        |       |   |           |   |--COMMA -> , [67:44]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:46]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [67:46]
        |       |   |           |       |--TYPE -> TYPE [67:46]
        |       |   |           |       |   `--IDENT -> C [67:46]
        |       |   |           |       `--IDENT -> t2 [67:48]
        |       |   |           `--RPAREN -> ) [67:50]
        |       |   |--RPAREN -> ) [67:51]
        |       |   |--SLIST -> { [67:53]
        |       |   |   |--EXPR -> EXPR [68:31]
        |       |   |   |   `--METHOD_CALL -> ( [68:31]
        |       |   |   |       |--DOT -> . [68:23]
        |       |   |   |       |   |--DOT -> . [68:19]
        |       |   |   |       |   |   |--IDENT -> System [68:13]
        |       |   |   |       |   |   `--IDENT -> out [68:20]
        |       |   |   |       |   `--IDENT -> println [68:24]
        |       |   |   |       |--ELIST -> ELIST [68:32]
        |       |   |   |       |   `--EXPR -> EXPR [68:32]
        |       |   |   |       |       `--IDENT -> t2 [68:32]
        |       |   |   |       `--RPAREN -> ) [68:34]
        |       |   |   |--SEMI -> ; [68:35]
        |       |   |   `--RCURLY -> } [69:9]
        |       |   `--LITERAL_ELSE -> else [70:9]
        |       |       `--LITERAL_IF -> if [70:14]
        |       |           |--LPAREN -> ( [70:17]
        |       |           |--EXPR -> EXPR [70:20]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [70:20]
        |       |           |       |--IDENT -> p [70:18]
        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [70:31]
        |       |           |           |--MODIFIERS -> MODIFIERS [70:31]
        |       |           |           |   |--ANNOTATION -> ANNOTATION [70:31]
        |       |           |           |   |   |--AT -> @ [70:31]
        |       |           |           |   |   `--IDENT -> MyAnno2 [70:32]
        |       |           |           |   `--FINAL -> final [70:40]
        |       |           |           |--TYPE -> TYPE [70:46]
        |       |           |           |   |--IDENT -> Pair [70:46]
        |       |           |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [70:50]
        |       |           |           |       |--GENERIC_START -> < [70:50]
        |       |           |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [70:51]
        |       |           |           |       |   `--IDENT -> I [70:51]
        |       |           |           |       `--GENERIC_END -> > [70:52]
        |       |           |           |--LPAREN -> ( [70:53]
        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [70:54]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [70:54]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [70:54]
        |       |           |           |   |   |--TYPE -> TYPE [70:54]
        |       |           |           |   |   |   `--IDENT -> D [70:54]
        |       |           |           |   |   `--IDENT -> t1 [70:56]
        |       |           |           |   |--COMMA -> , [70:58]
        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [70:60]
        |       |           |           |       |--MODIFIERS -> MODIFIERS [70:60]
        |       |           |           |       |--TYPE -> TYPE [70:60]
        |       |           |           |       |   `--IDENT -> D [70:60]
        |       |           |           |       `--IDENT -> t2 [70:62]
        |       |           |           `--RPAREN -> ) [70:64]
        |       |           |--RPAREN -> ) [70:65]
        |       |           `--SLIST -> { [70:67]
        |       |               |--EXPR -> EXPR [71:31]
        |       |               |   `--METHOD_CALL -> ( [71:31]
        |       |               |       |--DOT -> . [71:23]
        |       |               |       |   |--DOT -> . [71:19]
        |       |               |       |   |   |--IDENT -> System [71:13]
        |       |               |       |   |   `--IDENT -> out [71:20]
        |       |               |       |   `--IDENT -> println [71:24]
        |       |               |       |--ELIST -> ELIST [71:32]
        |       |               |       |   `--EXPR -> EXPR [71:32]
        |       |               |       |       `--IDENT -> t1 [71:32]
        |       |               |       `--RPAREN -> ) [71:34]
        |       |               |--SEMI -> ; [71:35]
        |       |               `--RCURLY -> } [72:9]
        |       `--RCURLY -> } [73:5]
        |--METHOD_DEF -> METHOD_DEF [75:5]
        |   |--MODIFIERS -> MODIFIERS [75:5]
        |   |   `--LITERAL_STATIC -> static [75:5]
        |   |--TYPE -> TYPE [75:12]
        |   |   `--LITERAL_VOID -> void [75:12]
        |   |--IDENT -> test5 [75:17]
        |   |--LPAREN -> ( [75:22]
        |   |--PARAMETERS -> PARAMETERS [75:23]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [75:23]
        |   |       |--MODIFIERS -> MODIFIERS [75:23]
        |   |       |--TYPE -> TYPE [75:23]
        |   |       |   `--IDENT -> Tuple [75:23]
        |   |       `--IDENT -> t [75:29]
        |   |--RPAREN -> ) [75:30]
        |   `--SLIST -> { [75:32]
        |       |--LITERAL_IF -> if [76:9]
        |       |   |--LPAREN -> ( [76:12]
        |       |   |--EXPR -> EXPR [76:15]
        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [76:15]
        |       |   |       |--IDENT -> t [76:13]
        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [76:26]
        |       |   |           |--MODIFIERS -> MODIFIERS [76:26]
        |       |   |           |--TYPE -> TYPE [76:26]
        |       |   |           |   `--IDENT -> Tuple [76:26]
        |       |   |           |--LPAREN -> ( [76:31]
        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [76:32]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:32]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [76:32]
        |       |   |           |   |   |--TYPE -> TYPE [76:32]
        |       |   |           |   |   |   `--IDENT -> String [76:32]
        |       |   |           |   |   `--IDENT -> x [76:39]
        |       |   |           |   |--COMMA -> , [76:40]
        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:42]
        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [76:42]
        |       |   |           |   |   |--TYPE -> TYPE [76:42]
        |       |   |           |   |   |   `--IDENT -> String [76:42]
        |       |   |           |   |   `--IDENT -> y [76:49]
        |       |   |           |   |--COMMA -> , [76:50]
        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:52]
        |       |   |           |       |--MODIFIERS -> MODIFIERS [76:52]
        |       |   |           |       |--TYPE -> TYPE [76:52]
        |       |   |           |       |   `--IDENT -> String [76:52]
        |       |   |           |       `--IDENT -> z [76:59]
        |       |   |           `--RPAREN -> ) [76:60]
        |       |   |--RPAREN -> ) [76:61]
        |       |   |--SLIST -> { [76:63]
        |       |   |   |--EXPR -> EXPR [77:31]
        |       |   |   |   `--METHOD_CALL -> ( [77:31]
        |       |   |   |       |--DOT -> . [77:23]
        |       |   |   |       |   |--DOT -> . [77:19]
        |       |   |   |       |   |   |--IDENT -> System [77:13]
        |       |   |   |       |   |   `--IDENT -> out [77:20]
        |       |   |   |       |   `--IDENT -> println [77:24]
        |       |   |   |       |--ELIST -> ELIST [77:38]
        |       |   |   |       |   `--EXPR -> EXPR [77:38]
        |       |   |   |       |       `--PLUS -> + [77:38]
        |       |   |   |       |           |--PLUS -> + [77:34]
        |       |   |   |       |           |   |--IDENT -> x [77:32]
        |       |   |   |       |           |   `--IDENT -> y [77:36]
        |       |   |   |       |           `--IDENT -> z [77:40]
        |       |   |   |       `--RPAREN -> ) [77:41]
        |       |   |   |--SEMI -> ; [77:42]
        |       |   |   `--RCURLY -> } [78:9]
        |       |   `--LITERAL_ELSE -> else [79:9]
        |       |       `--LITERAL_IF -> if [79:14]
        |       |           |--LPAREN -> ( [79:17]
        |       |           |--EXPR -> EXPR [79:20]
        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [79:20]
        |       |           |       |--IDENT -> t [79:18]
        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [79:31]
        |       |           |           |--MODIFIERS -> MODIFIERS [79:31]
        |       |           |           |   `--FINAL -> final [79:31]
        |       |           |           |--TYPE -> TYPE [79:37]
        |       |           |           |   `--IDENT -> Tuple [79:37]
        |       |           |           |--LPAREN -> ( [79:42]
        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [80:17]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [80:17]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [80:17]
        |       |           |           |   |   |   `--FINAL -> final [80:17]
        |       |           |           |   |   |--TYPE -> TYPE [80:23]
        |       |           |           |   |   |   `--IDENT -> Integer [80:23]
        |       |           |           |   |   `--IDENT -> x [80:31]
        |       |           |           |   |--COMMA -> , [80:32]
        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [81:17]
        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [81:17]
        |       |           |           |   |   |   `--ANNOTATION -> ANNOTATION [81:17]
        |       |           |           |   |   |       |--AT -> @ [81:17]
        |       |           |           |   |   |       `--IDENT -> MyAnno1 [81:18]
        |       |           |           |   |   |--TYPE -> TYPE [81:26]
        |       |           |           |   |   |   `--IDENT -> Integer [81:26]
        |       |           |           |   |   `--IDENT -> y [81:34]
        |       |           |           |   |--COMMA -> , [81:35]
        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [82:17]
        |       |           |           |       |--MODIFIERS -> MODIFIERS [82:17]
        |       |           |           |       |   |--FINAL -> final [82:17]
        |       |           |           |       |   |--ANNOTATION -> ANNOTATION [82:23]
        |       |           |           |       |   |   |--AT -> @ [82:23]
        |       |           |           |       |   |   `--IDENT -> MyAnno1 [82:24]
        |       |           |           |       |   `--ANNOTATION -> ANNOTATION [82:32]
        |       |           |           |       |       |--AT -> @ [82:32]
        |       |           |           |       |       `--IDENT -> MyAnno2 [82:33]
        |       |           |           |       |--TYPE -> TYPE [82:41]
        |       |           |           |       |   `--IDENT -> Integer [82:41]
        |       |           |           |       `--IDENT -> z [82:49]
        |       |           |           `--RPAREN -> ) [82:50]
        |       |           |--RPAREN -> ) [82:51]
        |       |           `--SLIST -> { [82:53]
        |       |               |--EXPR -> EXPR [83:31]
        |       |               |   `--METHOD_CALL -> ( [83:31]
        |       |               |       |--DOT -> . [83:23]
        |       |               |       |   |--DOT -> . [83:19]
        |       |               |       |   |   |--IDENT -> System [83:13]
        |       |               |       |   |   `--IDENT -> out [83:20]
        |       |               |       |   `--IDENT -> println [83:24]
        |       |               |       |--ELIST -> ELIST [83:38]
        |       |               |       |   `--EXPR -> EXPR [83:38]
        |       |               |       |       `--PLUS -> + [83:38]
        |       |               |       |           |--PLUS -> + [83:34]
        |       |               |       |           |   |--IDENT -> x [83:32]
        |       |               |       |           |   `--IDENT -> y [83:36]
        |       |               |       |           `--IDENT -> z [83:40]
        |       |               |       `--RPAREN -> ) [83:41]
        |       |               |--SEMI -> ; [83:42]
        |       |               `--RCURLY -> } [84:9]
        |       `--RCURLY -> } [85:5]
        |--METHOD_DEF -> METHOD_DEF [87:5]
        |   |--MODIFIERS -> MODIFIERS [87:5]
        |   |--TYPE -> TYPE [87:5]
        |   |   `--IDENT -> String [87:5]
        |   |--IDENT -> m2 [87:12]
        |   |--LPAREN -> ( [87:14]
        |   |--PARAMETERS -> PARAMETERS [87:15]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [87:15]
        |   |       |--MODIFIERS -> MODIFIERS [87:15]
        |   |       |--TYPE -> TYPE [87:15]
        |   |       |   |--IDENT -> Pair [87:15]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [87:19]
        |   |       |       |--GENERIC_START -> < [87:19]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [87:20]
        |   |       |       |   `--IDENT -> I [87:20]
        |   |       |       `--GENERIC_END -> > [87:21]
        |   |       `--IDENT -> p1 [87:23]
        |   |--RPAREN -> ) [87:25]
        |   `--SLIST -> { [87:27]
        |       |--LITERAL_RETURN -> return [88:9]
        |       |   |--EXPR -> EXPR [88:16]
        |       |   |   `--LITERAL_SWITCH -> switch [88:16]
        |       |   |       |--LPAREN -> ( [88:23]
        |       |   |       |--EXPR -> EXPR [88:24]
        |       |   |       |   `--IDENT -> p1 [88:24]
        |       |   |       |--RPAREN -> ) [88:26]
        |       |   |       |--LCURLY -> { [88:28]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [89:13]
        |       |   |       |   |--LITERAL_CASE -> case [89:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [89:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [89:18]
        |       |   |       |   |       |--TYPE -> TYPE [89:18]
        |       |   |       |   |       |   |--IDENT -> Pair [89:18]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:22]
        |       |   |       |   |       |       |--GENERIC_START -> < [89:22]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:23]
        |       |   |       |   |       |       |   `--IDENT -> I [89:23]
        |       |   |       |   |       |       `--GENERIC_END -> > [89:24]
        |       |   |       |   |       |--LPAREN -> ( [89:25]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [89:26]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [89:26]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [89:26]
        |       |   |       |   |       |   |   |   `--FINAL -> final [89:26]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [89:32]
        |       |   |       |   |       |   |   |   `--IDENT -> C [89:32]
        |       |   |       |   |       |   |   `--IDENT -> c [89:34]
        |       |   |       |   |       |   |--COMMA -> , [89:35]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [89:36]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [89:36]
        |       |   |       |   |       |       |   `--ANNOTATION -> ANNOTATION [89:36]
        |       |   |       |   |       |       |       |--AT -> @ [89:36]
        |       |   |       |   |       |       |       `--IDENT -> MyAnno2 [89:37]
        |       |   |       |   |       |       |--TYPE -> TYPE [89:45]
        |       |   |       |   |       |       |   `--IDENT -> I [89:45]
        |       |   |       |   |       |       `--IDENT -> i [89:47]
        |       |   |       |   |       `--RPAREN -> ) [89:48]
        |       |   |       |   |--LAMBDA -> -> [89:50]
        |       |   |       |   |--EXPR -> EXPR [89:53]
        |       |   |       |   |   `--STRING_LITERAL -> "T!" [89:53]
        |       |   |       |   `--SEMI -> ; [89:57]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [90:13]
        |       |   |       |   |--LITERAL_CASE -> case [90:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [90:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [90:18]
        |       |   |       |   |       |   `--FINAL -> final [90:18]
        |       |   |       |   |       |--TYPE -> TYPE [90:24]
        |       |   |       |   |       |   |--IDENT -> Pair [90:24]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [90:28]
        |       |   |       |   |       |       |--GENERIC_START -> < [90:28]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [90:29]
        |       |   |       |   |       |       |   `--IDENT -> I [90:29]
        |       |   |       |   |       |       `--GENERIC_END -> > [90:30]
        |       |   |       |   |       |--LPAREN -> ( [90:31]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [91:21]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [91:21]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [91:21]
        |       |   |       |   |       |   |   |   |--FINAL -> final [91:21]
        |       |   |       |   |       |   |   |   `--ANNOTATION -> ANNOTATION [91:27]
        |       |   |       |   |       |   |   |       |--AT -> @ [91:27]
        |       |   |       |   |       |   |   |       |--IDENT -> MyAnno3 [91:28]
        |       |   |       |   |       |   |   |       |--LPAREN -> ( [91:35]
        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:36]
        |       |   |       |   |       |   |   |       |   |--IDENT -> value [91:36]
        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [91:42]
        |       |   |       |   |       |   |   |       |   `--EXPR -> EXPR [91:44]
        |       |   |       |   |       |   |   |       |       `--STRING_LITERAL -> "some value" [91:44]
        |       |   |       |   |       |   |   |       |--COMMA -> , [91:56]
        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:58]
        |       |   |       |   |       |   |   |       |   |--IDENT -> values [91:58]
        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [91:65]
        |       |   |       |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [91:67]
        |       |   |       |   |       |   |   |       |       `--RCURLY -> } [91:68]
        |       |   |       |   |       |   |   |       `--RPAREN -> ) [91:69]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [91:71]
        |       |   |       |   |       |   |   |   `--IDENT -> D [91:71]
        |       |   |       |   |       |   |   `--IDENT -> d [91:73]
        |       |   |       |   |       |   |--COMMA -> , [91:74]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [92:21]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [92:21]
        |       |   |       |   |       |       |   `--FINAL -> final [92:21]
        |       |   |       |   |       |       |--TYPE -> TYPE [92:27]
        |       |   |       |   |       |       |   `--IDENT -> C [92:27]
        |       |   |       |   |       |       `--IDENT -> c [92:29]
        |       |   |       |   |       `--RPAREN -> ) [92:30]
        |       |   |       |   |--LAMBDA -> -> [92:32]
        |       |   |       |   |--EXPR -> EXPR [92:35]
        |       |   |       |   |   `--STRING_LITERAL -> "C!" [92:35]
        |       |   |       |   `--SEMI -> ; [92:39]
        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [93:13]
        |       |   |       |   |--LITERAL_CASE -> case [93:13]
        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [93:18]
        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [93:18]
        |       |   |       |   |       |--TYPE -> TYPE [93:18]
        |       |   |       |   |       |   |--IDENT -> Pair [93:18]
        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [93:22]
        |       |   |       |   |       |       |--GENERIC_START -> < [93:22]
        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [93:23]
        |       |   |       |   |       |       |   `--IDENT -> I [93:23]
        |       |   |       |   |       |       `--GENERIC_END -> > [93:24]
        |       |   |       |   |       |--LPAREN -> ( [93:25]
        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [94:21]
        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [94:21]
        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [94:21]
        |       |   |       |   |       |   |   |   `--ANNOTATION -> ANNOTATION [94:21]
        |       |   |       |   |       |   |   |       |--AT -> @ [94:21]
        |       |   |       |   |       |   |   |       |--IDENT -> MyAnno3 [94:22]
        |       |   |       |   |       |   |   |       |--LPAREN -> ( [94:29]
        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:30]
        |       |   |       |   |       |   |   |       |   |--IDENT -> value [94:30]
        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [94:36]
        |       |   |       |   |       |   |   |       |   `--EXPR -> EXPR [94:38]
        |       |   |       |   |       |   |   |       |       `--STRING_LITERAL -> "val" [94:38]
        |       |   |       |   |       |   |   |       |--COMMA -> , [94:43]
        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:45]
        |       |   |       |   |       |   |   |       |   |--IDENT -> values [94:45]
        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [94:52]
        |       |   |       |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [94:54]
        |       |   |       |   |       |   |   |       |       |--EXPR -> EXPR [94:55]
        |       |   |       |   |       |   |   |       |       |   `--STRING_LITERAL -> "1" [94:55]
        |       |   |       |   |       |   |   |       |       |--COMMA -> , [94:58]
        |       |   |       |   |       |   |   |       |       |--EXPR -> EXPR [94:60]
        |       |   |       |   |       |   |   |       |       |   `--STRING_LITERAL -> "2" [94:60]
        |       |   |       |   |       |   |   |       |       `--RCURLY -> } [94:63]
        |       |   |       |   |       |   |   |       `--RPAREN -> ) [94:64]
        |       |   |       |   |       |   |   |--TYPE -> TYPE [94:66]
        |       |   |       |   |       |   |   |   `--IDENT -> D [94:66]
        |       |   |       |   |       |   |   `--IDENT -> d1 [94:68]
        |       |   |       |   |       |   |--COMMA -> , [94:70]
        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [94:71]
        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [94:71]
        |       |   |       |   |       |       |--TYPE -> TYPE [94:71]
        |       |   |       |   |       |       |   `--IDENT -> D [94:71]
        |       |   |       |   |       |       `--IDENT -> d2 [94:73]
        |       |   |       |   |       `--RPAREN -> ) [94:75]
        |       |   |       |   |--LAMBDA -> -> [94:77]
        |       |   |       |   |--EXPR -> EXPR [94:80]
        |       |   |       |   |   `--STRING_LITERAL -> "D!" [94:80]
        |       |   |       |   `--SEMI -> ; [94:84]
        |       |   |       `--RCURLY -> } [95:9]
        |       |   `--SEMI -> ; [95:10]
        |       `--RCURLY -> } [96:5]
        |--METHOD_DEF -> METHOD_DEF [98:5]
        |   |--MODIFIERS -> MODIFIERS [98:5]
        |   |--TYPE -> TYPE [98:5]
        |   |   `--LITERAL_VOID -> void [98:5]
        |   |--IDENT -> m3 [98:10]
        |   |--LPAREN -> ( [98:13]
        |   |--PARAMETERS -> PARAMETERS [98:14]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [98:14]
        |   |       |--MODIFIERS -> MODIFIERS [98:14]
        |   |       |--TYPE -> TYPE [98:14]
        |   |       |   |--IDENT -> Pair [98:14]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [98:18]
        |   |       |       |--GENERIC_START -> < [98:18]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [98:19]
        |   |       |       |   |--IDENT -> Pair [98:19]
        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [98:23]
        |   |       |       |       |--GENERIC_START -> < [98:23]
        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [98:24]
        |   |       |       |       |   `--IDENT -> Integer [98:24]
        |   |       |       |       `--GENERIC_END -> > [98:31]
        |   |       |       `--GENERIC_END -> > [98:32]
        |   |       `--IDENT -> s [98:34]
        |   |--RPAREN -> ) [98:35]
        |   `--SLIST -> { [98:37]
        |       |--LITERAL_SWITCH -> switch [99:9]
        |       |   |--LPAREN -> ( [99:16]
        |       |   |--EXPR -> EXPR [99:17]
        |       |   |   `--IDENT -> s [99:17]
        |       |   |--RPAREN -> ) [99:18]
        |       |   |--LCURLY -> { [99:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [100:13]
        |       |   |   |--LITERAL_CASE -> case [100:13]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [100:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [100:18]
        |       |   |   |       |   `--FINAL -> final [100:18]
        |       |   |   |       |--TYPE -> TYPE [100:24]
        |       |   |   |       |   |--IDENT -> Pair [100:24]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:28]
        |       |   |   |       |       |--GENERIC_START -> < [100:28]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:29]
        |       |   |   |       |       |   |--IDENT -> Pair [100:29]
        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:33]
        |       |   |   |       |       |       |--GENERIC_START -> < [100:33]
        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:34]
        |       |   |   |       |       |       |   `--IDENT -> Integer [100:34]
        |       |   |   |       |       |       `--GENERIC_END -> > [100:41]
        |       |   |   |       |       `--GENERIC_END -> > [100:42]
        |       |   |   |       |--LPAREN -> ( [100:43]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:21]
        |       |   |   |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [101:21]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [101:21]
        |       |   |   |       |   |   |   `--ANNOTATION -> ANNOTATION [101:21]
        |       |   |   |       |   |   |       |--AT -> @ [101:21]
        |       |   |   |       |   |   |       `--IDENT -> MyAnno1 [101:22]
        |       |   |   |       |   |   |--TYPE -> TYPE [101:30]
        |       |   |   |       |   |   |   |--IDENT -> Pair [101:30]
        |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [101:34]
        |       |   |   |       |   |   |       |--GENERIC_START -> < [101:34]
        |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [101:35]
        |       |   |   |       |   |   |       |   `--IDENT -> Integer [101:35]
        |       |   |   |       |   |   |       `--GENERIC_END -> > [101:42]
        |       |   |   |       |   |   |--LPAREN -> ( [101:43]
        |       |   |   |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:44]
        |       |   |   |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [101:44]
        |       |   |   |       |   |   |   |   |--MODIFIERS -> MODIFIERS [101:44]
        |       |   |   |       |   |   |   |   |   `--ANNOTATION -> ANNOTATION [101:44]
        |       |   |   |       |   |   |   |   |       |--AT -> @ [101:44]
        |       |   |   |       |   |   |   |   |       `--IDENT -> MyAnno1 [101:45]
        |       |   |   |       |   |   |   |   |--TYPE -> TYPE [101:53]
        |       |   |   |       |   |   |   |   |   `--IDENT -> Integer [101:53]
        |       |   |   |       |   |   |   |   `--IDENT -> x1 [101:61]
        |       |   |   |       |   |   |   |--COMMA -> , [101:63]
        |       |   |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [101:65]
        |       |   |   |       |   |   |       |--MODIFIERS -> MODIFIERS [101:65]
        |       |   |   |       |   |   |       |   `--FINAL -> final [101:65]
        |       |   |   |       |   |   |       |--TYPE -> TYPE [101:71]
        |       |   |   |       |   |   |       |   `--IDENT -> Integer [101:71]
        |       |   |   |       |   |   |       `--IDENT -> y1 [101:79]
        |       |   |   |       |   |   |--RPAREN -> ) [101:81]
        |       |   |   |       |   |   `--IDENT -> x [101:83]
        |       |   |   |       |   |--COMMA -> , [101:84]
        |       |   |   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:21]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [102:21]
        |       |   |   |       |       |   `--FINAL -> final [102:21]
        |       |   |   |       |       |--TYPE -> TYPE [102:27]
        |       |   |   |       |       |   |--IDENT -> Pair [102:27]
        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [102:31]
        |       |   |   |       |       |       |--GENERIC_START -> < [102:31]
        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [102:32]
        |       |   |   |       |       |       |   `--IDENT -> Integer [102:32]
        |       |   |   |       |       |       `--GENERIC_END -> > [102:39]
        |       |   |   |       |       |--LPAREN -> ( [102:40]
        |       |   |   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:41]
        |       |   |   |       |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:41]
        |       |   |   |       |       |   |   |--MODIFIERS -> MODIFIERS [102:41]
        |       |   |   |       |       |   |   |--TYPE -> TYPE [102:41]
        |       |   |   |       |       |   |   |   `--IDENT -> Integer [102:41]
        |       |   |   |       |       |   |   `--IDENT -> x2 [102:49]
        |       |   |   |       |       |   |--COMMA -> , [102:51]
        |       |   |   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:53]
        |       |   |   |       |       |       |--MODIFIERS -> MODIFIERS [102:53]
        |       |   |   |       |       |       |--TYPE -> TYPE [102:53]
        |       |   |   |       |       |       |   `--IDENT -> Integer [102:53]
        |       |   |   |       |       |       `--IDENT -> y2 [102:61]
        |       |   |   |       |       |--RPAREN -> ) [102:63]
        |       |   |   |       |       `--IDENT -> p2 [102:65]
        |       |   |   |       |--RPAREN -> ) [102:67]
        |       |   |   |       `--IDENT -> y [102:69]
        |       |   |   |--LAMBDA -> -> [103:25]
        |       |   |   |--EXPR -> EXPR [103:46]
        |       |   |   |   `--METHOD_CALL -> ( [103:46]
        |       |   |   |       |--DOT -> . [103:38]
        |       |   |   |       |   |--DOT -> . [103:34]
        |       |   |   |       |   |   |--IDENT -> System [103:28]
        |       |   |   |       |   |   `--IDENT -> out [103:35]
        |       |   |   |       |   `--IDENT -> println [103:39]
        |       |   |   |       |--ELIST -> ELIST [103:47]
        |       |   |   |       `--RPAREN -> ) [103:47]
        |       |   |   `--SEMI -> ; [103:48]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [104:13]
        |       |   |   |--LITERAL_CASE -> case [104:13]
        |       |   |   |   `--LITERAL_DEFAULT -> default [104:18]
        |       |   |   |--LAMBDA -> -> [104:26]
        |       |   |   |--EXPR -> EXPR [104:47]
        |       |   |   |   `--METHOD_CALL -> ( [104:47]
        |       |   |   |       |--DOT -> . [104:39]
        |       |   |   |       |   |--DOT -> . [104:35]
        |       |   |   |       |   |   |--IDENT -> System [104:29]
        |       |   |   |       |   |   `--IDENT -> out [104:36]
        |       |   |   |       |   `--IDENT -> println [104:40]
        |       |   |   |       |--ELIST -> ELIST [104:48]
        |       |   |   |       `--RPAREN -> ) [104:48]
        |       |   |   `--SEMI -> ; [104:49]
        |       |   `--RCURLY -> } [105:9]
        |       `--RCURLY -> } [106:5]
        |--METHOD_DEF -> METHOD_DEF [108:5]
        |   |--MODIFIERS -> MODIFIERS [108:5]
        |   |--TYPE -> TYPE [108:5]
        |   |   `--LITERAL_VOID -> void [108:5]
        |   |--IDENT -> m4 [108:10]
        |   |--LPAREN -> ( [108:13]
        |   |--PARAMETERS -> PARAMETERS [108:14]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [108:14]
        |   |       |--MODIFIERS -> MODIFIERS [108:14]
        |   |       |--TYPE -> TYPE [108:14]
        |   |       |   |--IDENT -> Pair [108:14]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [108:18]
        |   |       |       |--GENERIC_START -> < [108:18]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [108:19]
        |   |       |       |   |--IDENT -> Pair [108:19]
        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [108:23]
        |   |       |       |       |--GENERIC_START -> < [108:23]
        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [108:24]
        |   |       |       |       |   `--IDENT -> Integer [108:24]
        |   |       |       |       `--GENERIC_END -> > [108:31]
        |   |       |       `--GENERIC_END -> > [108:32]
        |   |       `--IDENT -> s [108:34]
        |   |--RPAREN -> ) [108:35]
        |   `--SLIST -> { [108:37]
        |       |--LITERAL_SWITCH -> switch [109:9]
        |       |   |--LPAREN -> ( [109:16]
        |       |   |--EXPR -> EXPR [109:17]
        |       |   |   `--IDENT -> s [109:17]
        |       |   |--RPAREN -> ) [109:18]
        |       |   |--LCURLY -> { [109:20]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [110:13]
        |       |   |   |--LITERAL_CASE -> case [110:13]
        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [110:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [110:18]
        |       |   |   |       |   `--ANNOTATION -> ANNOTATION [110:18]
        |       |   |   |       |       |--AT -> @ [110:18]
        |       |   |   |       |       `--IDENT -> MyAnno2 [110:19]
        |       |   |   |       |--TYPE -> TYPE [110:27]
        |       |   |   |       |   |--IDENT -> Pair [110:27]
        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [110:31]
        |       |   |   |       |       |--GENERIC_START -> < [110:31]
        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [110:32]
        |       |   |   |       |       |   |--IDENT -> Pair [110:32]
        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [110:36]
        |       |   |   |       |       |       |--GENERIC_START -> < [110:36]
        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [110:37]
        |       |   |   |       |       |       |   `--IDENT -> Integer [110:37]
        |       |   |   |       |       |       `--GENERIC_END -> > [110:44]
        |       |   |   |       |       `--GENERIC_END -> > [110:45]
        |       |   |   |       |--LPAREN -> ( [110:46]
        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [111:21]
        |       |   |   |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [111:21]
        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [111:21]
        |       |   |   |       |   |   |   `--ANNOTATION -> ANNOTATION [111:21]
        |       |   |   |       |   |   |       |--AT -> @ [111:21]
        |       |   |   |       |   |   |       |--IDENT -> MyAnno3 [111:22]
        |       |   |   |       |   |   |       |--LPAREN -> ( [111:29]
        |       |   |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:30]
        |       |   |   |       |   |   |       |   |--IDENT -> value [111:30]
        |       |   |   |       |   |   |       |   |--ASSIGN -> = [111:36]
        |       |   |   |       |   |   |       |   `--EXPR -> EXPR [111:38]
        |       |   |   |       |   |   |       |       `--STRING_LITERAL -> "" [111:38]
        |       |   |   |       |   |   |       |--COMMA -> , [111:40]
        |       |   |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:42]
        |       |   |   |       |   |   |       |   |--IDENT -> values [111:42]
        |       |   |   |       |   |   |       |   |--ASSIGN -> = [111:49]
        |       |   |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [111:51]
        |       |   |   |       |   |   |       |       `--RCURLY -> } [111:52]
        |       |   |   |       |   |   |       `--RPAREN -> ) [111:53]
        |       |   |   |       |   |   |--TYPE -> TYPE [111:55]
        |       |   |   |       |   |   |   |--IDENT -> Pair [111:55]
        |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [111:59]
        |       |   |   |       |   |   |       |--GENERIC_START -> < [111:59]
        |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [111:60]
        |       |   |   |       |   |   |       |   `--IDENT -> Integer [111:60]
        |       |   |   |       |   |   |       `--GENERIC_END -> > [111:67]
        |       |   |   |       |   |   |--LPAREN -> ( [111:68]
        |       |   |   |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [112:29]
        |       |   |   |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:29]
        |       |   |   |       |   |   |   |   |--MODIFIERS -> MODIFIERS [112:29]
        |       |   |   |       |   |   |   |   |   `--FINAL -> final [112:29]
        |       |   |   |       |   |   |   |   |--TYPE -> TYPE [112:35]
        |       |   |   |       |   |   |   |   |   `--IDENT -> Integer [112:35]
        |       |   |   |       |   |   |   |   `--IDENT -> x1 [112:43]
        |       |   |   |       |   |   |   |--COMMA -> , [112:45]
        |       |   |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:46]
        |       |   |   |       |   |   |       |--MODIFIERS -> MODIFIERS [112:46]
        |       |   |   |       |   |   |       |--TYPE -> TYPE [112:46]
        |       |   |   |       |   |   |       |   `--IDENT -> Integer [112:46]
        |       |   |   |       |   |   |       `--IDENT -> y1 [112:54]
        |       |   |   |       |   |   |--RPAREN -> ) [112:56]
        |       |   |   |       |   |   `--IDENT -> x [112:58]
        |       |   |   |       |   |--COMMA -> , [112:59]
        |       |   |   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [113:22]
        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [113:22]
        |       |   |   |       |       |   |--ANNOTATION -> ANNOTATION [113:22]
        |       |   |   |       |       |   |   |--AT -> @ [113:22]
        |       |   |   |       |       |   |   |--IDENT -> MyAnno3 [113:23]
        |       |   |   |       |       |   |   |--LPAREN -> ( [113:30]
        |       |   |   |       |       |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [113:31]
        |       |   |   |       |       |   |   |   |--IDENT -> value [113:31]
        |       |   |   |       |       |   |   |   |--ASSIGN -> = [113:37]
        |       |   |   |       |       |   |   |   `--EXPR -> EXPR [113:39]
        |       |   |   |       |       |   |   |       `--STRING_LITERAL -> "" [113:39]
        |       |   |   |       |       |   |   |--COMMA -> , [113:41]
        |       |   |   |       |       |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [113:43]
        |       |   |   |       |       |   |   |   |--IDENT -> values [113:43]
        |       |   |   |       |       |   |   |   |--ASSIGN -> = [113:50]
        |       |   |   |       |       |   |   |   `--ANNOTATION_ARRAY_INIT -> { [113:52]
        |       |   |   |       |       |   |   |       `--RCURLY -> } [113:53]
        |       |   |   |       |       |   |   `--RPAREN -> ) [113:54]
        |       |   |   |       |       |   `--FINAL -> final [113:56]
        |       |   |   |       |       |--TYPE -> TYPE [113:62]
        |       |   |   |       |       |   |--IDENT -> Pair [113:62]
        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [113:66]
        |       |   |   |       |       |       |--GENERIC_START -> < [113:66]
        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [113:67]
        |       |   |   |       |       |       |   `--IDENT -> Integer [113:67]
        |       |   |   |       |       |       `--GENERIC_END -> > [113:74]
        |       |   |   |       |       |--LPAREN -> ( [113:75]
        |       |   |   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [114:30]
        |       |   |   |       |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [114:30]
        |       |   |   |       |       |   |   |--MODIFIERS -> MODIFIERS [114:30]
        |       |   |   |       |       |   |   |   |--ANNOTATION -> ANNOTATION [114:30]
        |       |   |   |       |       |   |   |   |   |--AT -> @ [114:30]
        |       |   |   |       |       |   |   |   |   `--IDENT -> MyAnno2 [114:31]
        |       |   |   |       |       |   |   |   `--FINAL -> final [114:39]
        |       |   |   |       |       |   |   |--TYPE -> TYPE [114:45]
        |       |   |   |       |       |   |   |   `--IDENT -> Integer [114:45]
        |       |   |   |       |       |   |   `--IDENT -> x2 [114:53]
        |       |   |   |       |       |   |--COMMA -> , [114:55]
        |       |   |   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [114:56]
        |       |   |   |       |       |       |--MODIFIERS -> MODIFIERS [114:56]
        |       |   |   |       |       |       |--TYPE -> TYPE [114:56]
        |       |   |   |       |       |       |   `--IDENT -> Integer [114:56]
        |       |   |   |       |       |       `--IDENT -> y2 [114:64]
        |       |   |   |       |       |--RPAREN -> ) [114:66]
        |       |   |   |       |       `--IDENT -> p2 [114:68]
        |       |   |   |       |--RPAREN -> ) [114:70]
        |       |   |   |       `--IDENT -> y [114:72]
        |       |   |   |--LAMBDA -> -> [115:37]
        |       |   |   |--EXPR -> EXPR [115:58]
        |       |   |   |   `--METHOD_CALL -> ( [115:58]
        |       |   |   |       |--DOT -> . [115:50]
        |       |   |   |       |   |--DOT -> . [115:46]
        |       |   |   |       |   |   |--IDENT -> System [115:40]
        |       |   |   |       |   |   `--IDENT -> out [115:47]
        |       |   |   |       |   `--IDENT -> println [115:51]
        |       |   |   |       |--ELIST -> ELIST [115:59]
        |       |   |   |       `--RPAREN -> ) [115:59]
        |       |   |   `--SEMI -> ; [115:60]
        |       |   |--SWITCH_RULE -> SWITCH_RULE [116:13]
        |       |   |   |--LITERAL_CASE -> case [116:13]
        |       |   |   |   `--LITERAL_DEFAULT -> default [116:18]
        |       |   |   |--LAMBDA -> -> [116:26]
        |       |   |   |--EXPR -> EXPR [116:47]
        |       |   |   |   `--METHOD_CALL -> ( [116:47]
        |       |   |   |       |--DOT -> . [116:39]
        |       |   |   |       |   |--DOT -> . [116:35]
        |       |   |   |       |   |   |--IDENT -> System [116:29]
        |       |   |   |       |   |   `--IDENT -> out [116:36]
        |       |   |   |       |   `--IDENT -> println [116:40]
        |       |   |   |       |--ELIST -> ELIST [116:48]
        |       |   |   |       `--RPAREN -> ) [116:48]
        |       |   |   `--SEMI -> ; [116:49]
        |       |   `--RCURLY -> } [117:9]
        |       `--RCURLY -> } [118:5]
        `--RCURLY -> } [119:1]
