COMPILATION_UNIT -> COMPILATION_UNIT [3:1]
|--SINGLE_LINE_COMMENT -> // [1:1]
|   `--COMMENT_CONTENT ->  non-compiled with eclipse: Syntax error on token "this", Identifier expected\n [1:3]
|--SINGLE_LINE_COMMENT -> // [2:1]
|   `--COMMENT_CONTENT ->  non-compiled with javac: Compilable with Java21 individually\n [2:3]
|--PACKAGE_DEF -> package [3:1]
|   |--ANNOTATIONS -> ANNOTATIONS [3:48]
|   |--DOT -> . [3:48]
|   |   |--DOT -> . [3:40]
|   |   |   |--DOT -> . [3:29]
|   |   |   |   |--DOT -> . [3:23]
|   |   |   |   |   |--DOT -> . [3:12]
|   |   |   |   |   |   |--IDENT -> com [3:9]
|   |   |   |   |   |   `--IDENT -> puppycrawl [3:13]
|   |   |   |   |   `--IDENT -> tools [3:24]
|   |   |   |   `--IDENT -> checkstyle [3:30]
|   |   |   `--IDENT -> grammar [3:41]
|   |   `--IDENT -> antlr4 [3:49]
|   `--SEMI -> ; [3:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputAntlr4AstRegressionUncommon3 [4:14]
    |--IMPLEMENTS_CLAUSE -> implements [4:48]
    |   `--IDENT -> AutoCloseable [4:59]
    `--OBJBLOCK -> OBJBLOCK [4:73]
        |--LCURLY -> { [4:73]
        |--METHOD_DEF -> METHOD_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |   |--ANNOTATION -> ANNOTATION [5:5]
        |   |   |   |--AT -> @ [5:5]
        |   |   |   `--IDENT -> Override [5:6]
        |   |   `--LITERAL_PUBLIC -> public [6:5]
        |   |--TYPE -> TYPE [6:12]
        |   |   `--LITERAL_VOID -> void [6:12]
        |   |--IDENT -> close [6:17]
        |   |--LPAREN -> ( [6:22]
        |   |--PARAMETERS -> PARAMETERS [6:23]
        |   |--RPAREN -> ) [6:23]
        |   |--LITERAL_THROWS -> throws [6:25]
        |   |   `--IDENT -> Exception [6:32]
        |   `--SLIST -> { [6:42]
        |       `--RCURLY -> } [8:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [10:5]
        |   |--MODIFIERS -> MODIFIERS [10:5]
        |   |--LITERAL_INTERFACE -> interface [10:5]
        |   |--IDENT -> SAM [10:15]
        |   `--OBJBLOCK -> OBJBLOCK [10:19]
        |       |--LCURLY -> { [10:19]
        |       |--METHOD_DEF -> METHOD_DEF [11:9]
        |       |   |--MODIFIERS -> MODIFIERS [11:9]
        |       |   |--TYPE -> TYPE [11:9]
        |       |   |   `--LITERAL_INT -> int [11:9]
        |       |   |--IDENT -> m [11:13]
        |       |   |--LPAREN -> ( [11:14]
        |       |   |--PARAMETERS -> PARAMETERS [11:15]
        |       |   |--RPAREN -> ) [11:15]
        |       |   `--SEMI -> ; [11:16]
        |       `--RCURLY -> } [12:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [14:5]
        |   |--MODIFIERS -> MODIFIERS [14:5]
        |   |--LITERAL_INTERFACE -> interface [14:5]
        |   |--IDENT -> SuperI [14:15]
        |   `--OBJBLOCK -> OBJBLOCK [14:22]
        |       |--LCURLY -> { [14:22]
        |       |--METHOD_DEF -> METHOD_DEF [15:9]
        |       |   |--MODIFIERS -> MODIFIERS [15:9]
        |       |   |   |--LITERAL_PUBLIC -> public [15:9]
        |       |   |   `--LITERAL_DEFAULT -> default [15:16]
        |       |   |--TYPE -> TYPE [15:24]
        |       |   |   `--LITERAL_INT -> int [15:24]
        |       |   |--IDENT -> foo [15:28]
        |       |   |--LPAREN -> ( [15:31]
        |       |   |--PARAMETERS -> PARAMETERS [15:32]
        |       |   |--RPAREN -> ) [15:32]
        |       |   `--SLIST -> { [15:34]
        |       |       |--LITERAL_RETURN -> return [15:36]
        |       |       |   |--EXPR -> EXPR [15:43]
        |       |       |   |   `--NUM_INT -> 1234 [15:43]
        |       |       |   `--SEMI -> ; [15:47]
        |       |       `--RCURLY -> } [15:49]
        |       `--RCURLY -> } [16:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [18:5]
        |   |--MODIFIERS -> MODIFIERS [18:5]
        |   |--LITERAL_INTERFACE -> interface [18:5]
        |   |--IDENT -> I [18:15]
        |   |--EXTENDS_CLAUSE -> extends [18:17]
        |   |   `--IDENT -> SuperI [18:25]
        |   `--OBJBLOCK -> OBJBLOCK [18:32]
        |       |--LCURLY -> { [18:32]
        |       `--RCURLY -> } [19:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [21:5]
        |   |--MODIFIERS -> MODIFIERS [21:5]
        |   |--LITERAL_INTERFACE -> interface [21:5]
        |   |--IDENT -> T [21:15]
        |   |--EXTENDS_CLAUSE -> extends [21:17]
        |   |   `--IDENT -> I [21:25]
        |   `--OBJBLOCK -> OBJBLOCK [21:27]
        |       |--LCURLY -> { [21:27]
        |       |--METHOD_DEF -> METHOD_DEF [22:9]
        |       |   |--MODIFIERS -> MODIFIERS [22:9]
        |       |   |   |--LITERAL_PUBLIC -> public [22:9]
        |       |   |   `--LITERAL_DEFAULT -> default [22:16]
        |       |   |--TYPE -> TYPE [22:24]
        |       |   |   `--IDENT -> SAM [22:24]
        |       |   |--IDENT -> boo [22:28]
        |       |   |--LPAREN -> ( [22:31]
        |       |   |--PARAMETERS -> PARAMETERS [22:32]
        |       |   |--RPAREN -> ) [22:32]
        |       |   `--SLIST -> { [22:34]
        |       |       |--LITERAL_RETURN -> return [22:36]
        |       |       |   |--EXPR -> EXPR [22:50]
        |       |       |   |   `--METHOD_REF -> :: [22:50]
        |       |       |   |       |--DOT -> . [22:44]
        |       |       |   |       |   |--IDENT -> I [22:43]
        |       |       |   |       |   `--LITERAL_SUPER -> super [22:45]
        |       |       |   |       `--IDENT -> foo [22:52]
        |       |       |   `--SEMI -> ; [22:55]
        |       |       `--RCURLY -> } [22:57]
        |       `--RCURLY -> } [23:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [25:5]
        |   |--MODIFIERS -> MODIFIERS [25:5]
        |   |--LITERAL_INTERFACE -> interface [25:5]
        |   |--IDENT -> DSPRI [25:15]
        |   `--OBJBLOCK -> OBJBLOCK [25:21]
        |       |--LCURLY -> { [25:21]
        |       |--METHOD_DEF -> METHOD_DEF [25:23]
        |       |   |--MODIFIERS -> MODIFIERS [25:23]
        |       |   |--TYPE -> TYPE [25:23]
        |       |   |   `--IDENT -> String [25:23]
        |       |   |--IDENT -> m [25:30]
        |       |   |--LPAREN -> ( [25:31]
        |       |   |--PARAMETERS -> PARAMETERS [25:32]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:32]
        |       |   |       |--MODIFIERS -> MODIFIERS [25:32]
        |       |   |       |--TYPE -> TYPE [25:32]
        |       |   |       |   `--IDENT -> String [25:32]
        |       |   |       `--IDENT -> a [25:39]
        |       |   |--RPAREN -> ) [25:40]
        |       |   `--SEMI -> ; [25:41]
        |       `--RCURLY -> } [25:43]
        |--INTERFACE_DEF -> INTERFACE_DEF [27:5]
        |   |--MODIFIERS -> MODIFIERS [27:5]
        |   |--LITERAL_INTERFACE -> interface [27:5]
        |   |--IDENT -> DSPRA [27:15]
        |   `--OBJBLOCK -> OBJBLOCK [27:21]
        |       |--LCURLY -> { [27:21]
        |       |--METHOD_DEF -> METHOD_DEF [28:9]
        |       |   |--MODIFIERS -> MODIFIERS [28:9]
        |       |   |   `--LITERAL_DEFAULT -> default [28:9]
        |       |   |--TYPE -> TYPE [28:17]
        |       |   |   `--IDENT -> String [28:17]
        |       |   |--IDENT -> xsA__ [28:24]
        |       |   |--LPAREN -> ( [28:29]
        |       |   |--PARAMETERS -> PARAMETERS [28:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [28:30]
        |       |   |       |--MODIFIERS -> MODIFIERS [28:30]
        |       |   |       |--TYPE -> TYPE [28:30]
        |       |   |       |   `--IDENT -> String [28:30]
        |       |   |       `--IDENT -> s [28:37]
        |       |   |--RPAREN -> ) [28:38]
        |       |   `--SLIST -> { [28:40]
        |       |       |--LITERAL_RETURN -> return [29:13]
        |       |       |   |--EXPR -> EXPR [29:30]
        |       |       |   |   `--PLUS -> + [29:30]
        |       |       |   |       |--STRING_LITERAL -> "A__xsA:" [29:20]
        |       |       |   |       `--IDENT -> s [29:32]
        |       |       |   `--SEMI -> ; [29:33]
        |       |       `--RCURLY -> } [30:9]
        |       |--METHOD_DEF -> METHOD_DEF [32:9]
        |       |   |--MODIFIERS -> MODIFIERS [32:9]
        |       |   |   `--LITERAL_DEFAULT -> default [32:9]
        |       |   |--TYPE -> TYPE [32:17]
        |       |   |   `--IDENT -> String [32:17]
        |       |   |--IDENT -> xsAB_ [32:24]
        |       |   |--LPAREN -> ( [32:29]
        |       |   |--PARAMETERS -> PARAMETERS [32:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [32:30]
        |       |   |       |--MODIFIERS -> MODIFIERS [32:30]
        |       |   |       |--TYPE -> TYPE [32:30]
        |       |   |       |   `--IDENT -> String [32:30]
        |       |   |       `--IDENT -> s [32:37]
        |       |   |--RPAREN -> ) [32:38]
        |       |   `--SLIST -> { [32:40]
        |       |       |--LITERAL_RETURN -> return [33:13]
        |       |       |   |--EXPR -> EXPR [33:30]
        |       |       |   |   `--PLUS -> + [33:30]
        |       |       |   |       |--STRING_LITERAL -> "AB_xsA:" [33:20]
        |       |       |   |       `--IDENT -> s [33:32]
        |       |       |   `--SEMI -> ; [33:33]
        |       |       `--RCURLY -> } [34:9]
        |       `--RCURLY -> } [36:5]
        |--INTERFACE_DEF -> INTERFACE_DEF [38:5]
        |   |--MODIFIERS -> MODIFIERS [38:5]
        |   |--LITERAL_INTERFACE -> interface [38:5]
        |   |--IDENT -> DSPRB [38:15]
        |   |--EXTENDS_CLAUSE -> extends [38:21]
        |   |   `--IDENT -> DSPRA [38:29]
        |   `--OBJBLOCK -> OBJBLOCK [38:35]
        |       |--LCURLY -> { [38:35]
        |       |--METHOD_DEF -> METHOD_DEF [40:9]
        |       |   |--MODIFIERS -> MODIFIERS [40:9]
        |       |   |   `--LITERAL_DEFAULT -> default [40:9]
        |       |   |--TYPE -> TYPE [40:17]
        |       |   |   `--IDENT -> String [40:17]
        |       |   |--IDENT -> xsAB_ [40:24]
        |       |   |--LPAREN -> ( [40:29]
        |       |   |--PARAMETERS -> PARAMETERS [40:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [40:30]
        |       |   |       |--MODIFIERS -> MODIFIERS [40:30]
        |       |   |       |--TYPE -> TYPE [40:30]
        |       |   |       |   `--IDENT -> String [40:30]
        |       |   |       `--IDENT -> s [40:37]
        |       |   |--RPAREN -> ) [40:38]
        |       |   `--SLIST -> { [40:40]
        |       |       |--LITERAL_RETURN -> return [41:13]
        |       |       |   |--EXPR -> EXPR [41:30]
        |       |       |   |   `--PLUS -> + [41:30]
        |       |       |   |       |--STRING_LITERAL -> "AB_xsB:" [41:20]
        |       |       |   |       `--IDENT -> s [41:32]
        |       |       |   `--SEMI -> ; [41:33]
        |       |       `--RCURLY -> } [42:9]
        |       |--METHOD_DEF -> METHOD_DEF [44:9]
        |       |   |--MODIFIERS -> MODIFIERS [44:9]
        |       |   |   `--LITERAL_DEFAULT -> default [44:9]
        |       |   |--TYPE -> TYPE [44:17]
        |       |   |   `--IDENT -> String [44:17]
        |       |   |--IDENT -> xs_B_ [44:24]
        |       |   |--LPAREN -> ( [44:29]
        |       |   |--PARAMETERS -> PARAMETERS [44:30]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [44:30]
        |       |   |       |--MODIFIERS -> MODIFIERS [44:30]
        |       |   |       |--TYPE -> TYPE [44:30]
        |       |   |       |   `--IDENT -> String [44:30]
        |       |   |       `--IDENT -> s [44:37]
        |       |   |--RPAREN -> ) [44:38]
        |       |   `--SLIST -> { [44:40]
        |       |       |--LITERAL_RETURN -> return [45:13]
        |       |       |   |--EXPR -> EXPR [45:30]
        |       |       |   |   `--PLUS -> + [45:30]
        |       |       |   |       |--STRING_LITERAL -> "_B_xsB:" [45:20]
        |       |       |   |       `--IDENT -> s [45:32]
        |       |       |   `--SEMI -> ; [45:33]
        |       |       `--RCURLY -> } [46:9]
        |       `--RCURLY -> } [48:5]
        |--CLASS_DEF -> CLASS_DEF [50:5]
        |   |--MODIFIERS -> MODIFIERS [50:5]
        |   |   `--LITERAL_PUBLIC -> public [50:5]
        |   |--LITERAL_CLASS -> class [50:12]
        |   |--IDENT -> MethodReferenceTestSuperDefault [50:18]
        |   |--IMPLEMENTS_CLAUSE -> implements [50:50]
        |   |   `--IDENT -> DSPRB [50:61]
        |   `--OBJBLOCK -> OBJBLOCK [50:67]
        |       |--LCURLY -> { [50:67]
        |       |--METHOD_DEF -> METHOD_DEF [52:9]
        |       |   |--MODIFIERS -> MODIFIERS [52:9]
        |       |   |   `--LITERAL_PUBLIC -> public [52:9]
        |       |   |--TYPE -> TYPE [52:16]
        |       |   |   `--LITERAL_VOID -> void [52:16]
        |       |   |--IDENT -> testMethodReferenceSuper [52:21]
        |       |   |--LPAREN -> ( [52:45]
        |       |   |--PARAMETERS -> PARAMETERS [52:46]
        |       |   |--RPAREN -> ) [52:46]
        |       |   `--SLIST -> { [52:48]
        |       |       |--VARIABLE_DEF -> VARIABLE_DEF [53:13]
        |       |       |   |--MODIFIERS -> MODIFIERS [53:13]
        |       |       |   |--TYPE -> TYPE [53:13]
        |       |       |   |   `--IDENT -> DSPRI [53:13]
        |       |       |   `--IDENT -> q [53:19]
        |       |       |--SEMI -> ; [53:20]
        |       |       |--EXPR -> EXPR [55:15]
        |       |       |   `--ASSIGN -> = [55:15]
        |       |       |       |--IDENT -> q [55:13]
        |       |       |       `--METHOD_REF -> :: [55:28]
        |       |       |           |--DOT -> . [55:22]
        |       |       |           |   |--IDENT -> DSPRB [55:17]
        |       |       |           |   `--LITERAL_SUPER -> super [55:23]
        |       |       |           `--IDENT -> xsA__ [55:30]
        |       |       |--SEMI -> ; [55:35]
        |       |       |--EXPR -> EXPR [57:15]
        |       |       |   `--ASSIGN -> = [57:15]
        |       |       |       |--IDENT -> q [57:13]
        |       |       |       `--METHOD_REF -> :: [57:28]
        |       |       |           |--DOT -> . [57:22]
        |       |       |           |   |--IDENT -> DSPRB [57:17]
        |       |       |           |   `--LITERAL_SUPER -> super [57:23]
        |       |       |           `--IDENT -> xsAB_ [57:30]
        |       |       |--SEMI -> ; [57:35]
        |       |       |--EXPR -> EXPR [59:15]
        |       |       |   `--ASSIGN -> = [59:15]
        |       |       |       |--IDENT -> q [59:13]
        |       |       |       `--METHOD_REF -> :: [59:28]
        |       |       |           |--DOT -> . [59:22]
        |       |       |           |   |--IDENT -> DSPRB [59:17]
        |       |       |           |   `--LITERAL_SUPER -> super [59:23]
        |       |       |           `--IDENT -> xs_B_ [59:30]
        |       |       |--SEMI -> ; [59:35]
        |       |       `--RCURLY -> } [60:9]
        |       `--RCURLY -> } [62:5]
        |--METHOD_DEF -> METHOD_DEF [64:5]
        |   |--MODIFIERS -> MODIFIERS [64:5]
        |   |--TYPE -> TYPE [64:5]
        |   |   `--LITERAL_VOID -> void [64:5]
        |   |--IDENT -> test [64:10]
        |   |--LPAREN -> ( [64:14]
        |   |--PARAMETERS -> PARAMETERS [64:15]
        |   |--RPAREN -> ) [64:15]
        |   |--LITERAL_THROWS -> throws [64:17]
        |   |   `--IDENT -> Exception [64:24]
        |   `--SLIST -> { [64:34]
        |       |--LITERAL_TRY -> try [65:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [65:13]
        |       |   |   |--LPAREN -> ( [65:13]
        |       |   |   |--RESOURCES -> RESOURCES [65:47]
        |       |   |   |   `--RESOURCE -> RESOURCE [65:47]
        |       |   |   |       `--DOT -> . [65:47]
        |       |   |   |           |--IDENT -> InputAntlr4AstRegressionUncommon3 [65:14]
        |       |   |   |           `--LITERAL_THIS -> this [65:48]
        |       |   |   `--RPAREN -> ) [65:52]
        |       |   `--SLIST -> { [65:54]
        |       |       |--EXPR -> EXPR [66:31]
        |       |       |   `--METHOD_CALL -> ( [66:31]
        |       |       |       |--DOT -> . [66:23]
        |       |       |       |   |--DOT -> . [66:19]
        |       |       |       |   |   |--IDENT -> System [66:13]
        |       |       |       |   |   `--IDENT -> out [66:20]
        |       |       |       |   `--IDENT -> println [66:24]
        |       |       |       |--ELIST -> ELIST [66:32]
        |       |       |       |   `--EXPR -> EXPR [66:32]
        |       |       |       |       `--STRING_LITERAL -> "Unable to process" [66:32]
        |       |       |       `--RPAREN -> ) [66:51]
        |       |       |--SEMI -> ; [66:52]
        |       |       `--RCURLY -> } [67:9]
        |       `--RCURLY -> } [68:5]
        `--RCURLY -> } [70:1]
