COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:40]
|   |--DOT -> . [1:40]
|   |   |--DOT -> . [1:29]
|   |   |   |--DOT -> . [1:23]
|   |   |   |   |--DOT -> . [1:12]
|   |   |   |   |   |--IDENT -> com [1:9]
|   |   |   |   |   `--IDENT -> puppycrawl [1:13]
|   |   |   |   `--IDENT -> tools [1:24]
|   |   |   `--IDENT -> checkstyle [1:30]
|   |   `--IDENT -> grammar [1:41]
|   `--SEMI -> ; [1:48]
`--CLASS_DEF -> CLASS_DEF [3:1]
    |--MODIFIERS -> MODIFIERS [3:1]
    |   `--LITERAL_PUBLIC -> public [3:1]
    |--LITERAL_CLASS -> class [3:8]
    |--IDENT -> InputAstRegressionTryWithResourcesOnAutoCloseable [3:14]
    `--OBJBLOCK -> OBJBLOCK [3:64]
        |--LCURLY -> { [3:64]
        |--CLASS_DEF -> CLASS_DEF [4:5]
        |   |--MODIFIERS -> MODIFIERS [4:5]
        |   |   `--LITERAL_STATIC -> static [4:5]
        |   |--LITERAL_CLASS -> class [4:12]
        |   |--IDENT -> T [4:18]
        |   |--IMPLEMENTS_CLAUSE -> implements [4:20]
        |   |   `--IDENT -> AutoCloseable [4:31]
        |   `--OBJBLOCK -> OBJBLOCK [4:45]
        |       |--LCURLY -> { [4:45]
        |       |--METHOD_DEF -> METHOD_DEF [5:9]
        |       |   |--MODIFIERS -> MODIFIERS [5:9]
        |       |   |   `--LITERAL_PUBLIC -> public [5:9]
        |       |   |--TYPE -> TYPE [5:16]
        |       |   |   `--LITERAL_VOID -> void [5:16]
        |       |   |--IDENT -> doIt [5:21]
        |       |   |--LPAREN -> ( [5:25]
        |       |   |--PARAMETERS -> PARAMETERS [5:26]
        |       |   |--RPAREN -> ) [5:26]
        |       |   `--SLIST -> { [5:28]
        |       |       |--EXPR -> EXPR [6:17]
        |       |       |   `--METHOD_CALL -> ( [6:17]
        |       |       |       |--IDENT -> open [6:13]
        |       |       |       |--ELIST -> ELIST [6:18]
        |       |       |       `--RPAREN -> ) [6:18]
        |       |       |--SEMI -> ; [6:19]
        |       |       |--LITERAL_TRY -> try [7:13]
        |       |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [7:17]
        |       |       |   |   |--LPAREN -> ( [7:17]
        |       |       |   |   |--RESOURCES -> RESOURCES [7:18]
        |       |       |   |   |   `--RESOURCE -> RESOURCE [7:18]
        |       |       |   |   |       `--LITERAL_THIS -> this [7:18]
        |       |       |   |   `--RPAREN -> ) [7:22]
        |       |       |   `--SLIST -> { [7:24]
        |       |       |       |--EXPR -> EXPR [8:35]
        |       |       |       |   `--METHOD_CALL -> ( [8:35]
        |       |       |       |       |--DOT -> . [8:27]
        |       |       |       |       |   |--DOT -> . [8:23]
        |       |       |       |       |   |   |--IDENT -> System [8:17]
        |       |       |       |       |   |   `--IDENT -> out [8:24]
        |       |       |       |       |   `--IDENT -> println [8:28]
        |       |       |       |       |--ELIST -> ELIST [8:36]
        |       |       |       |       |   `--EXPR -> EXPR [8:36]
        |       |       |       |       |       `--STRING_LITERAL -> "doIt" [8:36]
        |       |       |       |       `--RPAREN -> ) [8:42]
        |       |       |       |--SEMI -> ; [8:43]
        |       |       |       `--RCURLY -> } [9:13]
        |       |       |--VARIABLE_DEF -> VARIABLE_DEF [11:13]
        |       |       |   |--MODIFIERS -> MODIFIERS [11:13]
        |       |       |   |--TYPE -> TYPE [11:13]
        |       |       |   |   `--IDENT -> T [11:13]
        |       |       |   |--IDENT -> t [11:15]
        |       |       |   `--ASSIGN -> = [11:17]
        |       |       |       `--EXPR -> EXPR [11:19]
        |       |       |           `--LITERAL_NEW -> new [11:19]
        |       |       |               |--IDENT -> T [11:23]
        |       |       |               |--LPAREN -> ( [11:24]
        |       |       |               |--ELIST -> ELIST [11:25]
        |       |       |               `--RPAREN -> ) [11:25]
        |       |       |--SEMI -> ; [11:26]
        |       |       |--LITERAL_TRY -> try [13:13]
        |       |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [13:17]
        |       |       |   |   |--LPAREN -> ( [13:17]
        |       |       |   |   |--RESOURCES -> RESOURCES [13:18]
        |       |       |   |   |   `--RESOURCE -> RESOURCE [13:18]
        |       |       |   |   |       `--IDENT -> t [13:18]
        |       |       |   |   `--RPAREN -> ) [13:19]
        |       |       |   `--SLIST -> { [13:21]
        |       |       |       |--EXPR -> EXPR [14:35]
        |       |       |       |   `--METHOD_CALL -> ( [14:35]
        |       |       |       |       |--DOT -> . [14:27]
        |       |       |       |       |   |--DOT -> . [14:23]
        |       |       |       |       |   |   |--IDENT -> System [14:17]
        |       |       |       |       |   |   `--IDENT -> out [14:24]
        |       |       |       |       |   `--IDENT -> println [14:28]
        |       |       |       |       |--ELIST -> ELIST [14:36]
        |       |       |       |       |   `--EXPR -> EXPR [14:36]
        |       |       |       |       |       `--STRING_LITERAL -> "doIt" [14:36]
        |       |       |       |       `--RPAREN -> ) [14:42]
        |       |       |       |--SEMI -> ; [14:43]
        |       |       |       `--RCURLY -> } [15:13]
        |       |       `--RCURLY -> } [16:9]
        |       |--METHOD_DEF -> METHOD_DEF [18:9]
        |       |   |--MODIFIERS -> MODIFIERS [18:9]
        |       |   |   `--LITERAL_PUBLIC -> public [18:9]
        |       |   |--TYPE -> TYPE [18:16]
        |       |   |   `--LITERAL_VOID -> void [18:16]
        |       |   |--IDENT -> open [18:21]
        |       |   |--LPAREN -> ( [18:25]
        |       |   |--PARAMETERS -> PARAMETERS [18:26]
        |       |   |--RPAREN -> ) [18:26]
        |       |   `--SLIST -> { [18:28]
        |       |       |--EXPR -> EXPR [19:31]
        |       |       |   `--METHOD_CALL -> ( [19:31]
        |       |       |       |--DOT -> . [19:23]
        |       |       |       |   |--DOT -> . [19:19]
        |       |       |       |   |   |--IDENT -> System [19:13]
        |       |       |       |   |   `--IDENT -> out [19:20]
        |       |       |       |   `--IDENT -> println [19:24]
        |       |       |       |--ELIST -> ELIST [19:32]
        |       |       |       |   `--EXPR -> EXPR [19:32]
        |       |       |       |       `--STRING_LITERAL -> "open" [19:32]
        |       |       |       `--RPAREN -> ) [19:38]
        |       |       |--SEMI -> ; [19:39]
        |       |       `--RCURLY -> } [20:9]
        |       |--METHOD_DEF -> METHOD_DEF [22:9]
        |       |   |--MODIFIERS -> MODIFIERS [22:9]
        |       |   |   |--ANNOTATION -> ANNOTATION [22:9]
        |       |   |   |   |--AT -> @ [22:9]
        |       |   |   |   `--IDENT -> Override [22:10]
        |       |   |   `--LITERAL_PUBLIC -> public [23:9]
        |       |   |--TYPE -> TYPE [23:16]
        |       |   |   `--LITERAL_VOID -> void [23:16]
        |       |   |--IDENT -> close [23:21]
        |       |   |--LPAREN -> ( [23:26]
        |       |   |--PARAMETERS -> PARAMETERS [23:27]
        |       |   |--RPAREN -> ) [23:27]
        |       |   `--SLIST -> { [23:29]
        |       |       |--EXPR -> EXPR [24:31]
        |       |       |   `--METHOD_CALL -> ( [24:31]
        |       |       |       |--DOT -> . [24:23]
        |       |       |       |   |--DOT -> . [24:19]
        |       |       |       |   |   |--IDENT -> System [24:13]
        |       |       |       |   |   `--IDENT -> out [24:20]
        |       |       |       |   `--IDENT -> println [24:24]
        |       |       |       |--ELIST -> ELIST [24:32]
        |       |       |       |   `--EXPR -> EXPR [24:32]
        |       |       |       |       `--STRING_LITERAL -> "close" [24:32]
        |       |       |       `--RPAREN -> ) [24:39]
        |       |       |--SEMI -> ; [24:40]
        |       |       `--RCURLY -> } [25:9]
        |       `--RCURLY -> } [26:5]
        `--RCURLY -> } [27:1]
