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 -> InputJava19PatternsInNullSwitch2 [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:47]
        |--LCURLY -> { [4:47]
        |--CLASS_DEF -> CLASS_DEF [6:5]
        |   |--MODIFIERS -> MODIFIERS [6:5]
        |   |--LITERAL_CLASS -> class [6:5]
        |   |--IDENT -> Super [6:11]
        |   `--OBJBLOCK -> OBJBLOCK [6:17]
        |       |--LCURLY -> { [6:17]
        |       `--RCURLY -> } [6:18]
        |--CLASS_DEF -> CLASS_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |--LITERAL_CLASS -> class [7:5]
        |   |--IDENT -> Sub [7:11]
        |   |--EXTENDS_CLAUSE -> extends [7:15]
        |   |   `--IDENT -> Super [7:23]
        |   `--OBJBLOCK -> OBJBLOCK [7:29]
        |       |--LCURLY -> { [7:29]
        |       `--RCURLY -> } [7:30]
        |--RECORD_DEF -> RECORD_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |--LITERAL_RECORD -> record [8:5]
        |   |--IDENT -> R [8:12]
        |   |--LPAREN -> ( [8:13]
        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:14]
        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:14]
        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:14]
        |   |       |--TYPE -> TYPE [8:14]
        |   |       |   `--IDENT -> Super [8:14]
        |   |       `--IDENT -> s [8:20]
        |   |--RPAREN -> ) [8:21]
        |   `--OBJBLOCK -> OBJBLOCK [8:23]
        |       |--LCURLY -> { [8:23]
        |       `--RCURLY -> } [8:24]
        |--METHOD_DEF -> METHOD_DEF [10:5]
        |   |--MODIFIERS -> MODIFIERS [10:5]
        |   |   `--LITERAL_PRIVATE -> private [10:5]
        |   |--TYPE -> TYPE [10:13]
        |   |   `--LITERAL_INT -> int [10:13]
        |   |--IDENT -> matchingSwitch9b [10:17]
        |   |--LPAREN -> ( [10:33]
        |   |--PARAMETERS -> PARAMETERS [10:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:34]
        |   |       |--MODIFIERS -> MODIFIERS [10:34]
        |   |       |--TYPE -> TYPE [10:34]
        |   |       |   `--IDENT -> Object [10:34]
        |   |       `--IDENT -> obj [10:41]
        |   |--RPAREN -> ) [10:44]
        |   `--SLIST -> { [10:46]
        |       |--LITERAL_TRY -> try [11:9]
        |       |   |--SLIST -> { [11:13]
        |       |   |   |--LITERAL_RETURN -> return [12:13]
        |       |   |   |   |--EXPR -> EXPR [12:20]
        |       |   |   |   |   `--LITERAL_SWITCH -> switch [12:20]
        |       |   |   |   |       |--LPAREN -> ( [12:27]
        |       |   |   |   |       |--EXPR -> EXPR [12:28]
        |       |   |   |   |       |   `--IDENT -> obj [12:28]
        |       |   |   |   |       |--RPAREN -> ) [12:31]
        |       |   |   |   |       |--LCURLY -> { [12:33]
        |       |   |   |   |       |--CASE_GROUP -> CASE_GROUP [13:17]
        |       |   |   |   |       |   |--LITERAL_CASE -> case [13:17]
        |       |   |   |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [13:22]
        |       |   |   |   |       |   |   |   |--MODIFIERS -> MODIFIERS [13:22]
        |       |   |   |   |       |   |   |   |--TYPE -> TYPE [13:22]
        |       |   |   |   |       |   |   |   |   `--IDENT -> String [13:22]
        |       |   |   |   |       |   |   |   `--IDENT -> s [13:29]
        |       |   |   |   |       |   |   `--COLON -> : [13:30]
        |       |   |   |   |       |   `--SLIST -> SLIST [13:32]
        |       |   |   |   |       |       `--LITERAL_YIELD -> yield [13:32]
        |       |   |   |   |       |           |--EXPR -> EXPR [13:38]
        |       |   |   |   |       |           |   `--NUM_INT -> 0 [13:38]
        |       |   |   |   |       |           `--SEMI -> ; [13:39]
        |       |   |   |   |       |--CASE_GROUP -> CASE_GROUP [14:17]
        |       |   |   |   |       |   |--LITERAL_CASE -> case [14:17]
        |       |   |   |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:22]
        |       |   |   |   |       |   |   |   |--MODIFIERS -> MODIFIERS [14:22]
        |       |   |   |   |       |   |   |   |--TYPE -> TYPE [14:22]
        |       |   |   |   |       |   |   |   |   `--IDENT -> Object [14:22]
        |       |   |   |   |       |   |   |   `--IDENT -> o [14:29]
        |       |   |   |   |       |   |   `--COLON -> : [14:30]
        |       |   |   |   |       |   `--SLIST -> SLIST [14:32]
        |       |   |   |   |       |       `--LITERAL_YIELD -> yield [14:32]
        |       |   |   |   |       |           |--EXPR -> EXPR [14:38]
        |       |   |   |   |       |           |   `--NUM_INT -> 1 [14:38]
        |       |   |   |   |       |           `--SEMI -> ; [14:39]
        |       |   |   |   |       `--RCURLY -> } [15:13]
        |       |   |   |   `--SEMI -> ; [15:14]
        |       |   |   `--RCURLY -> } [16:9]
        |       |   `--LITERAL_CATCH -> catch [16:11]
        |       |       |--LPAREN -> ( [16:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [16:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [16:18]
        |       |       |   |--TYPE -> TYPE [16:18]
        |       |       |   |   `--IDENT -> NullPointerException [16:18]
        |       |       |   `--IDENT -> ex [16:39]
        |       |       |--RPAREN -> ) [16:41]
        |       |       `--SLIST -> { [16:43]
        |       |           |--LITERAL_RETURN -> return [17:13]
        |       |           |   |--EXPR -> EXPR [17:20]
        |       |           |   |   `--NUM_INT -> 2 [17:20]
        |       |           |   `--SEMI -> ; [17:21]
        |       |           `--RCURLY -> } [18:9]
        |       `--RCURLY -> } [19:5]
        |--METHOD_DEF -> METHOD_DEF [21:5]
        |   |--MODIFIERS -> MODIFIERS [21:5]
        |   |   `--LITERAL_PRIVATE -> private [21:5]
        |   |--TYPE -> TYPE [21:13]
        |   |   `--LITERAL_INT -> int [21:13]
        |   |--IDENT -> matchingSwitch10b [21:17]
        |   |--LPAREN -> ( [21:34]
        |   |--PARAMETERS -> PARAMETERS [21:35]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:35]
        |   |       |--MODIFIERS -> MODIFIERS [21:35]
        |   |       |--TYPE -> TYPE [21:35]
        |   |       |   `--IDENT -> Object [21:35]
        |   |       `--IDENT -> obj [21:42]
        |   |--RPAREN -> ) [21:45]
        |   `--SLIST -> { [21:47]
        |       |--LITERAL_TRY -> try [22:9]
        |       |   |--SLIST -> { [22:13]
        |       |   |   |--LITERAL_SWITCH -> switch [23:13]
        |       |   |   |   |--LPAREN -> ( [23:20]
        |       |   |   |   |--EXPR -> EXPR [23:21]
        |       |   |   |   |   `--IDENT -> obj [23:21]
        |       |   |   |   |--RPAREN -> ) [23:24]
        |       |   |   |   |--LCURLY -> { [23:26]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [24:17]
        |       |   |   |   |   |--LITERAL_CASE -> case [24:17]
        |       |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:22]
        |       |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [24:22]
        |       |   |   |   |   |   |   |--TYPE -> TYPE [24:22]
        |       |   |   |   |   |   |   |   `--IDENT -> String [24:22]
        |       |   |   |   |   |   |   `--IDENT -> s [24:29]
        |       |   |   |   |   |   `--COLON -> : [24:30]
        |       |   |   |   |   `--SLIST -> SLIST [24:32]
        |       |   |   |   |       `--LITERAL_RETURN -> return [24:32]
        |       |   |   |   |           |--EXPR -> EXPR [24:39]
        |       |   |   |   |           |   `--NUM_INT -> 0 [24:39]
        |       |   |   |   |           `--SEMI -> ; [24:40]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [25:17]
        |       |   |   |   |   |--LITERAL_CASE -> case [25:17]
        |       |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [25:22]
        |       |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [25:22]
        |       |   |   |   |   |   |   |--TYPE -> TYPE [25:22]
        |       |   |   |   |   |   |   |   `--IDENT -> Object [25:22]
        |       |   |   |   |   |   |   `--IDENT -> o [25:29]
        |       |   |   |   |   |   `--COLON -> : [25:30]
        |       |   |   |   |   `--SLIST -> SLIST [25:32]
        |       |   |   |   |       `--LITERAL_RETURN -> return [25:32]
        |       |   |   |   |           |--EXPR -> EXPR [25:39]
        |       |   |   |   |           |   `--NUM_INT -> 1 [25:39]
        |       |   |   |   |           `--SEMI -> ; [25:40]
        |       |   |   |   `--RCURLY -> } [26:13]
        |       |   |   `--RCURLY -> } [27:9]
        |       |   `--LITERAL_CATCH -> catch [27:11]
        |       |       |--LPAREN -> ( [27:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [27:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [27:18]
        |       |       |   |--TYPE -> TYPE [27:18]
        |       |       |   |   `--IDENT -> NullPointerException [27:18]
        |       |       |   `--IDENT -> ex [27:39]
        |       |       |--RPAREN -> ) [27:41]
        |       |       `--SLIST -> { [27:43]
        |       |           |--LITERAL_RETURN -> return [28:13]
        |       |           |   |--EXPR -> EXPR [28:20]
        |       |           |   |   `--NUM_INT -> 2 [28:20]
        |       |           |   `--SEMI -> ; [28:21]
        |       |           `--RCURLY -> } [29:9]
        |       `--RCURLY -> } [30:5]
        |--METHOD_DEF -> METHOD_DEF [32:5]
        |   |--MODIFIERS -> MODIFIERS [32:5]
        |   |   `--LITERAL_PRIVATE -> private [32:5]
        |   |--TYPE -> TYPE [32:13]
        |   |   `--LITERAL_INT -> int [32:13]
        |   |--IDENT -> matchingSwitch11 [32:17]
        |   |--LPAREN -> ( [32:33]
        |   |--PARAMETERS -> PARAMETERS [32:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [32:34]
        |   |       |--MODIFIERS -> MODIFIERS [32:34]
        |   |       |--TYPE -> TYPE [32:34]
        |   |       |   `--IDENT -> Object [32:34]
        |   |       `--IDENT -> obj [32:41]
        |   |--RPAREN -> ) [32:44]
        |   `--SLIST -> { [32:46]
        |       |--LITERAL_TRY -> try [33:9]
        |       |   |--SLIST -> { [33:13]
        |       |   |   |--LITERAL_RETURN -> return [34:13]
        |       |   |   |   |--EXPR -> EXPR [34:20]
        |       |   |   |   |   `--LITERAL_SWITCH -> switch [34:20]
        |       |   |   |   |       |--LPAREN -> ( [34:27]
        |       |   |   |   |       |--EXPR -> EXPR [34:28]
        |       |   |   |   |       |   `--IDENT -> obj [34:28]
        |       |   |   |   |       |--RPAREN -> ) [34:31]
        |       |   |   |   |       |--LCURLY -> { [34:33]
        |       |   |   |   |       |--CASE_GROUP -> CASE_GROUP [35:17]
        |       |   |   |   |       |   |--LITERAL_CASE -> case [35:17]
        |       |   |   |   |       |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [35:22]
        |       |   |   |   |       |   |   |   |--MODIFIERS -> MODIFIERS [35:22]
        |       |   |   |   |       |   |   |   |--TYPE -> TYPE [35:22]
        |       |   |   |   |       |   |   |   |   `--IDENT -> String [35:22]
        |       |   |   |   |       |   |   |   `--IDENT -> s [35:29]
        |       |   |   |   |       |   |   `--COLON -> : [35:30]
        |       |   |   |   |       |   `--SLIST -> SLIST [35:32]
        |       |   |   |   |       |       `--LITERAL_YIELD -> yield [35:32]
        |       |   |   |   |       |           |--EXPR -> EXPR [35:38]
        |       |   |   |   |       |           |   `--NUM_INT -> 0 [35:38]
        |       |   |   |   |       |           `--SEMI -> ; [35:39]
        |       |   |   |   |       |--CASE_GROUP -> CASE_GROUP [36:17]
        |       |   |   |   |       |   |--LITERAL_DEFAULT -> default [36:17]
        |       |   |   |   |       |   |   `--COLON -> : [36:24]
        |       |   |   |   |       |   `--SLIST -> SLIST [36:26]
        |       |   |   |   |       |       `--LITERAL_YIELD -> yield [36:26]
        |       |   |   |   |       |           |--EXPR -> EXPR [36:32]
        |       |   |   |   |       |           |   `--NUM_INT -> 1 [36:32]
        |       |   |   |   |       |           `--SEMI -> ; [36:33]
        |       |   |   |   |       `--RCURLY -> } [37:13]
        |       |   |   |   `--SEMI -> ; [37:14]
        |       |   |   `--RCURLY -> } [38:9]
        |       |   `--LITERAL_CATCH -> catch [38:11]
        |       |       |--LPAREN -> ( [38:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [38:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [38:18]
        |       |       |   |--TYPE -> TYPE [38:18]
        |       |       |   |   `--IDENT -> NullPointerException [38:18]
        |       |       |   `--IDENT -> ex [38:39]
        |       |       |--RPAREN -> ) [38:41]
        |       |       `--SLIST -> { [38:43]
        |       |           |--LITERAL_RETURN -> return [39:13]
        |       |           |   |--EXPR -> EXPR [39:20]
        |       |           |   |   `--NUM_INT -> 2 [39:20]
        |       |           |   `--SEMI -> ; [39:21]
        |       |           `--RCURLY -> } [40:9]
        |       `--RCURLY -> } [41:5]
        |--METHOD_DEF -> METHOD_DEF [43:5]
        |   |--MODIFIERS -> MODIFIERS [43:5]
        |   |   `--LITERAL_PRIVATE -> private [43:5]
        |   |--TYPE -> TYPE [43:13]
        |   |   `--LITERAL_INT -> int [43:13]
        |   |--IDENT -> matchingSwitch12 [43:17]
        |   |--LPAREN -> ( [43:33]
        |   |--PARAMETERS -> PARAMETERS [43:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [43:34]
        |   |       |--MODIFIERS -> MODIFIERS [43:34]
        |   |       |--TYPE -> TYPE [43:34]
        |   |       |   `--IDENT -> Object [43:34]
        |   |       `--IDENT -> obj [43:41]
        |   |--RPAREN -> ) [43:44]
        |   `--SLIST -> { [43:46]
        |       |--LITERAL_TRY -> try [44:9]
        |       |   |--SLIST -> { [44:13]
        |       |   |   |--LITERAL_SWITCH -> switch [45:13]
        |       |   |   |   |--LPAREN -> ( [45:20]
        |       |   |   |   |--EXPR -> EXPR [45:21]
        |       |   |   |   |   `--IDENT -> obj [45:21]
        |       |   |   |   |--RPAREN -> ) [45:24]
        |       |   |   |   |--LCURLY -> { [45:26]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [46:17]
        |       |   |   |   |   |--LITERAL_CASE -> case [46:17]
        |       |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:22]
        |       |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [46:22]
        |       |   |   |   |   |   |   |--TYPE -> TYPE [46:22]
        |       |   |   |   |   |   |   |   `--IDENT -> String [46:22]
        |       |   |   |   |   |   |   `--IDENT -> s [46:29]
        |       |   |   |   |   |   `--COLON -> : [46:30]
        |       |   |   |   |   `--SLIST -> SLIST [46:32]
        |       |   |   |   |       `--LITERAL_RETURN -> return [46:32]
        |       |   |   |   |           |--EXPR -> EXPR [46:39]
        |       |   |   |   |           |   `--NUM_INT -> 0 [46:39]
        |       |   |   |   |           `--SEMI -> ; [46:40]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [47:17]
        |       |   |   |   |   |--LITERAL_DEFAULT -> default [47:17]
        |       |   |   |   |   |   `--COLON -> : [47:24]
        |       |   |   |   |   `--SLIST -> SLIST [47:26]
        |       |   |   |   |       `--LITERAL_RETURN -> return [47:26]
        |       |   |   |   |           |--EXPR -> EXPR [47:33]
        |       |   |   |   |           |   `--NUM_INT -> 1 [47:33]
        |       |   |   |   |           `--SEMI -> ; [47:34]
        |       |   |   |   `--RCURLY -> } [48:13]
        |       |   |   `--RCURLY -> } [49:9]
        |       |   `--LITERAL_CATCH -> catch [49:11]
        |       |       |--LPAREN -> ( [49:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [49:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [49:18]
        |       |       |   |--TYPE -> TYPE [49:18]
        |       |       |   |   `--IDENT -> NullPointerException [49:18]
        |       |       |   `--IDENT -> ex [49:39]
        |       |       |--RPAREN -> ) [49:41]
        |       |       `--SLIST -> { [49:43]
        |       |           |--LITERAL_RETURN -> return [50:13]
        |       |           |   |--EXPR -> EXPR [50:20]
        |       |           |   |   `--NUM_INT -> 2 [50:20]
        |       |           |   `--SEMI -> ; [50:21]
        |       |           `--RCURLY -> } [51:9]
        |       `--RCURLY -> } [52:5]
        |--METHOD_DEF -> METHOD_DEF [54:5]
        |   |--MODIFIERS -> MODIFIERS [54:5]
        |   |   `--LITERAL_PRIVATE -> private [54:5]
        |   |--TYPE -> TYPE [54:13]
        |   |   `--LITERAL_INT -> int [54:13]
        |   |--IDENT -> matchingSwitch13 [54:17]
        |   |--LPAREN -> ( [54:33]
        |   |--PARAMETERS -> PARAMETERS [54:34]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [54:34]
        |   |       |--MODIFIERS -> MODIFIERS [54:34]
        |   |       |--TYPE -> TYPE [54:34]
        |   |       |   `--IDENT -> Object [54:34]
        |   |       `--IDENT -> obj [54:41]
        |   |--RPAREN -> ) [54:44]
        |   `--SLIST -> { [54:46]
        |       |--LITERAL_TRY -> try [55:9]
        |       |   |--SLIST -> { [55:13]
        |       |   |   |--LITERAL_SWITCH -> switch [56:13]
        |       |   |   |   |--LPAREN -> ( [56:20]
        |       |   |   |   |--EXPR -> EXPR [56:21]
        |       |   |   |   |   `--IDENT -> obj [56:21]
        |       |   |   |   |--RPAREN -> ) [56:24]
        |       |   |   |   |--LCURLY -> { [56:26]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [57:17]
        |       |   |   |   |   |--LITERAL_DEFAULT -> default [57:17]
        |       |   |   |   |   |   `--COLON -> : [57:24]
        |       |   |   |   |   `--SLIST -> SLIST [57:26]
        |       |   |   |   |       `--LITERAL_RETURN -> return [57:26]
        |       |   |   |   |           |--EXPR -> EXPR [57:33]
        |       |   |   |   |           |   `--NUM_INT -> 1 [57:33]
        |       |   |   |   |           `--SEMI -> ; [57:34]
        |       |   |   |   |--CASE_GROUP -> CASE_GROUP [58:17]
        |       |   |   |   |   |--LITERAL_CASE -> case [58:17]
        |       |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [58:22]
        |       |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [58:22]
        |       |   |   |   |   |   |   |--TYPE -> TYPE [58:22]
        |       |   |   |   |   |   |   |   `--IDENT -> String [58:22]
        |       |   |   |   |   |   |   `--IDENT -> s [58:29]
        |       |   |   |   |   |   `--COLON -> : [58:30]
        |       |   |   |   |   `--SLIST -> SLIST [58:32]
        |       |   |   |   |       `--LITERAL_RETURN -> return [58:32]
        |       |   |   |   |           |--EXPR -> EXPR [58:39]
        |       |   |   |   |           |   `--NUM_INT -> 0 [58:39]
        |       |   |   |   |           `--SEMI -> ; [58:40]
        |       |   |   |   `--RCURLY -> } [59:13]
        |       |   |   `--RCURLY -> } [60:9]
        |       |   `--LITERAL_CATCH -> catch [60:11]
        |       |       |--LPAREN -> ( [60:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [60:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [60:18]
        |       |       |   |--TYPE -> TYPE [60:18]
        |       |       |   |   `--IDENT -> NullPointerException [60:18]
        |       |       |   `--IDENT -> ex [60:39]
        |       |       |--RPAREN -> ) [60:41]
        |       |       `--SLIST -> { [60:43]
        |       |           |--LITERAL_RETURN -> return [61:13]
        |       |           |   |--EXPR -> EXPR [61:20]
        |       |           |   |   `--NUM_INT -> 2 [61:20]
        |       |           |   `--SEMI -> ; [61:21]
        |       |           `--RCURLY -> } [62:9]
        |       `--RCURLY -> } [63:5]
        `--RCURLY -> } [64:1]
