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 -> java9 [2:49]
|   `--SEMI -> ; [2:54]
`--CLASS_DEF -> CLASS_DEF [7:1]
    |--MODIFIERS -> MODIFIERS [7:1]
    |   `--LITERAL_PUBLIC -> public [7:1]
    |--LITERAL_CLASS -> class [7:8]
    |--IDENT -> InputAdvanceJava9TryWithResources [7:14]
    |--IMPLEMENTS_CLAUSE -> implements [7:48]
    |   `--IDENT -> AutoCloseable [7:59]
    `--OBJBLOCK -> OBJBLOCK [8:1]
        |--LCURLY -> { [8:1]
        |--METHOD_DEF -> METHOD_DEF [9:5]
        |   |--MODIFIERS -> MODIFIERS [9:5]
        |   |   |--LITERAL_PUBLIC -> public [9:5]
        |   |   `--LITERAL_STATIC -> static [9:12]
        |   |--TYPE -> TYPE [9:19]
        |   |   `--LITERAL_VOID -> void [9:19]
        |   |--IDENT -> main [9:24]
        |   |--LPAREN -> ( [9:28]
        |   |--PARAMETERS -> PARAMETERS [9:29]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [9:29]
        |   |       |--MODIFIERS -> MODIFIERS [9:29]
        |   |       |--TYPE -> TYPE [9:29]
        |   |       |   |--IDENT -> String [9:29]
        |   |       |   `--ARRAY_DECLARATOR -> [ [9:35]
        |   |       |       `--RBRACK -> ] [9:36]
        |   |       `--IDENT -> args [9:38]
        |   |--RPAREN -> ) [9:42]
        |   |--LITERAL_THROWS -> throws [9:44]
        |   |   `--IDENT -> Exception [9:51]
        |   `--SLIST -> { [9:61]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [10:9]
        |       |   |--MODIFIERS -> MODIFIERS [10:9]
        |       |   |--TYPE -> TYPE [10:9]
        |       |   |   `--IDENT -> InputAdvanceJava9TryWithResources [10:9]
        |       |   |--IDENT -> v [10:43]
        |       |   `--ASSIGN -> = [10:45]
        |       |       `--EXPR -> EXPR [10:47]
        |       |           `--LITERAL_NEW -> new [10:47]
        |       |               |--IDENT -> InputAdvanceJava9TryWithResources [10:51]
        |       |               |--LPAREN -> ( [10:84]
        |       |               |--ELIST -> ELIST [10:85]
        |       |               `--RPAREN -> ) [10:85]
        |       |--SEMI -> ; [10:86]
        |       |--LITERAL_TRY -> try [12:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [12:13]
        |       |   |   |--LPAREN -> ( [12:13]
        |       |   |   |--RESOURCES -> RESOURCES [12:28]
        |       |   |   |   `--RESOURCE -> RESOURCE [12:28]
        |       |   |   |       `--DOT -> . [12:28]
        |       |   |   |           |--DOT -> . [12:15]
        |       |   |   |           |   |--IDENT -> v [12:14]
        |       |   |   |           |   `--IDENT -> finalWrapper [12:16]
        |       |   |   |           `--IDENT -> finalField [12:29]
        |       |   |   `--RPAREN -> ) [12:39]
        |       |   `--SLIST -> { [12:41]
        |       |       `--RCURLY -> } [13:9]
        |       |--LITERAL_TRY -> try [15:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [15:13]
        |       |   |   |--LPAREN -> ( [15:13]
        |       |   |   |--RESOURCES -> RESOURCES [15:70]
        |       |   |   |   `--RESOURCE -> RESOURCE [15:70]
        |       |   |   |       `--DOT -> . [15:70]
        |       |   |   |           |--DOT -> . [15:57]
        |       |   |   |           |   |--LITERAL_NEW -> new [15:14]
        |       |   |   |           |   |   |--IDENT -> InputAdvanceJava9TryWithResources [15:18]
        |       |   |   |           |   |   |--LPAREN -> ( [15:51]
        |       |   |   |           |   |   |--ELIST -> ELIST [15:52]
        |       |   |   |           |   |   |--RPAREN -> ) [15:52]
        |       |   |   |           |   |   `--OBJBLOCK -> OBJBLOCK [15:54]
        |       |   |   |           |   |       |--LCURLY -> { [15:54]
        |       |   |   |           |   |       `--RCURLY -> } [15:56]
        |       |   |   |           |   `--IDENT -> finalWrapper [15:58]
        |       |   |   |           `--IDENT -> finalField [15:71]
        |       |   |   `--RPAREN -> ) [15:81]
        |       |   `--SLIST -> { [15:83]
        |       |       `--RCURLY -> } [16:9]
        |       |--LITERAL_TRY -> try [18:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [18:13]
        |       |   |   |--LPAREN -> ( [18:13]
        |       |   |   |--RESOURCES -> RESOURCES [19:72]
        |       |   |   |   `--RESOURCE -> RESOURCE [19:72]
        |       |   |   |       `--DOT -> . [19:72]
        |       |   |   |           |--DOT -> . [19:59]
        |       |   |   |           |   |--LPAREN -> ( [18:14]
        |       |   |   |           |   |--QUESTION -> ? [18:31]
        |       |   |   |           |   |   |--GT -> > [18:27]
        |       |   |   |           |   |   |   |--DOT -> . [18:19]
        |       |   |   |           |   |   |   |   |--IDENT -> args [18:15]
        |       |   |   |           |   |   |   |   `--IDENT -> length [18:20]
        |       |   |   |           |   |   |   `--NUM_INT -> 0 [18:29]
        |       |   |   |           |   |   |--IDENT -> v [18:33]
        |       |   |   |           |   |   |--COLON -> : [19:17]
        |       |   |   |           |   |   `--LITERAL_NEW -> new [19:19]
        |       |   |   |           |   |       |--IDENT -> InputAdvanceJava9TryWithResources [19:23]
        |       |   |   |           |   |       |--LPAREN -> ( [19:56]
        |       |   |   |           |   |       |--ELIST -> ELIST [19:57]
        |       |   |   |           |   |       `--RPAREN -> ) [19:57]
        |       |   |   |           |   |--RPAREN -> ) [19:58]
        |       |   |   |           |   `--IDENT -> finalWrapper [19:60]
        |       |   |   |           `--IDENT -> finalField [19:73]
        |       |   |   `--RPAREN -> ) [19:83]
        |       |   `--SLIST -> { [19:85]
        |       |       `--RCURLY -> } [20:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [23:9]
        |       |   |--MODIFIERS -> MODIFIERS [23:9]
        |       |   |--TYPE -> TYPE [23:9]
        |       |   |   `--IDENT -> InputAdvanceJava9TryWithResources [23:9]
        |       |   |--IDENT -> i1 [23:43]
        |       |   `--ASSIGN -> = [23:46]
        |       |       `--EXPR -> EXPR [23:48]
        |       |           `--LITERAL_NEW -> new [23:48]
        |       |               |--IDENT -> InputAdvanceJava9TryWithResources [23:52]
        |       |               |--LPAREN -> ( [23:85]
        |       |               |--ELIST -> ELIST [23:86]
        |       |               `--RPAREN -> ) [23:86]
        |       |--SEMI -> ; [23:87]
        |       |--LITERAL_TRY -> try [24:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [24:13]
        |       |   |   |--LPAREN -> ( [24:13]
        |       |   |   |--RESOURCES -> RESOURCES [24:14]
        |       |   |   |   |--RESOURCE -> RESOURCE [24:14]
        |       |   |   |   |   `--IDENT -> i1 [24:14]
        |       |   |   |   |--SEMI -> ; [24:16]
        |       |   |   |   `--RESOURCE -> RESOURCE [24:18]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [24:18]
        |       |   |   |       |--TYPE -> TYPE [24:18]
        |       |   |   |       |   `--IDENT -> InputAdvanceJava9TryWithResources [24:18]
        |       |   |   |       |--IDENT -> i2 [24:52]
        |       |   |   |       `--ASSIGN -> = [24:55]
        |       |   |   |           `--EXPR -> EXPR [25:21]
        |       |   |   |               `--LITERAL_NEW -> new [25:21]
        |       |   |   |                   |--IDENT -> InputAdvanceJava9TryWithResources [25:25]
        |       |   |   |                   |--LPAREN -> ( [25:58]
        |       |   |   |                   |--ELIST -> ELIST [25:59]
        |       |   |   |                   `--RPAREN -> ) [25:59]
        |       |   |   `--RPAREN -> ) [25:60]
        |       |   `--SLIST -> { [25:62]
        |       |       `--RCURLY -> } [26:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [28:9]
        |       |   |--MODIFIERS -> MODIFIERS [28:9]
        |       |   |--TYPE -> TYPE [28:9]
        |       |   |   `--IDENT -> InputAdvanceJava9TryWithResources [28:9]
        |       |   |--IDENT -> m1 [28:43]
        |       |   `--ASSIGN -> = [28:46]
        |       |       `--EXPR -> EXPR [28:48]
        |       |           `--LITERAL_NEW -> new [28:48]
        |       |               |--IDENT -> InputAdvanceJava9TryWithResources [28:52]
        |       |               |--LPAREN -> ( [28:85]
        |       |               |--ELIST -> ELIST [28:86]
        |       |               `--RPAREN -> ) [28:86]
        |       |--SEMI -> ; [28:87]
        |       |--LITERAL_TRY -> try [29:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [29:13]
        |       |   |   |--LPAREN -> ( [29:13]
        |       |   |   |--RESOURCES -> RESOURCES [29:14]
        |       |   |   |   |--RESOURCE -> RESOURCE [29:14]
        |       |   |   |   |   `--IDENT -> m1 [29:14]
        |       |   |   |   |--SEMI -> ; [29:16]
        |       |   |   |   |--RESOURCE -> RESOURCE [29:18]
        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [29:18]
        |       |   |   |   |   |--TYPE -> TYPE [29:18]
        |       |   |   |   |   |   `--IDENT -> InputAdvanceJava9TryWithResources [29:18]
        |       |   |   |   |   |--IDENT -> m2 [29:52]
        |       |   |   |   |   `--ASSIGN -> = [29:55]
        |       |   |   |   |       `--EXPR -> EXPR [29:57]
        |       |   |   |   |           `--IDENT -> m1 [29:57]
        |       |   |   |   |--SEMI -> ; [29:59]
        |       |   |   |   `--RESOURCE -> RESOURCE [30:17]
        |       |   |   |       |--MODIFIERS -> MODIFIERS [30:17]
        |       |   |   |       |--TYPE -> TYPE [30:17]
        |       |   |   |       |   `--IDENT -> InputAdvanceJava9TryWithResources [30:17]
        |       |   |   |       |--IDENT -> m3 [30:51]
        |       |   |   |       `--ASSIGN -> = [30:54]
        |       |   |   |           `--EXPR -> EXPR [30:56]
        |       |   |   |               `--IDENT -> m2 [30:56]
        |       |   |   |--SEMI -> ; [30:58]
        |       |   |   `--RPAREN -> ) [30:59]
        |       |   `--SLIST -> { [30:61]
        |       |       `--RCURLY -> } [31:9]
        |       `--RCURLY -> } [32:5]
        |--VARIABLE_DEF -> VARIABLE_DEF [34:5]
        |   |--MODIFIERS -> MODIFIERS [34:5]
        |   |   |--FINAL -> final [34:5]
        |   |   `--LITERAL_STATIC -> static [34:11]
        |   |--TYPE -> TYPE [34:18]
        |   |   `--IDENT -> FinalWrapper [34:18]
        |   |--IDENT -> finalWrapper [34:31]
        |   |--ASSIGN -> = [34:44]
        |   |   `--EXPR -> EXPR [34:46]
        |   |       `--LITERAL_NEW -> new [34:46]
        |   |           |--IDENT -> FinalWrapper [34:50]
        |   |           |--LPAREN -> ( [34:62]
        |   |           |--ELIST -> ELIST [34:63]
        |   |           `--RPAREN -> ) [34:63]
        |   `--SEMI -> ; [34:64]
        |--METHOD_DEF -> METHOD_DEF [35:5]
        |   |--MODIFIERS -> MODIFIERS [35:5]
        |   |   `--LITERAL_PUBLIC -> public [35:5]
        |   |--TYPE -> TYPE [35:12]
        |   |   `--LITERAL_VOID -> void [35:12]
        |   |--IDENT -> method [35:17]
        |   |--LPAREN -> ( [35:23]
        |   |--PARAMETERS -> PARAMETERS [35:24]
        |   |--RPAREN -> ) [35:24]
        |   |--LITERAL_THROWS -> throws [35:26]
        |   |   `--IDENT -> Exception [35:33]
        |   `--SLIST -> { [35:43]
        |       |--LITERAL_TRY -> try [36:9]
        |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [36:12]
        |       |   |   |--LPAREN -> ( [36:12]
        |       |   |   |--RESOURCES -> RESOURCES [36:30]
        |       |   |   |   `--RESOURCE -> RESOURCE [36:30]
        |       |   |   |       `--DOT -> . [36:30]
        |       |   |   |           |--DOT -> . [36:17]
        |       |   |   |           |   |--LITERAL_THIS -> this [36:13]
        |       |   |   |           |   `--IDENT -> finalWrapper [36:18]
        |       |   |   |           `--IDENT -> finalField [36:31]
        |       |   |   `--RPAREN -> ) [36:41]
        |       |   `--SLIST -> { [36:43]
        |       |       `--RCURLY -> } [37:9]
        |       `--RCURLY -> } [38:5]
        |--CLASS_DEF -> CLASS_DEF [39:5]
        |   |--MODIFIERS -> MODIFIERS [39:5]
        |   |   `--LITERAL_STATIC -> static [39:5]
        |   |--LITERAL_CLASS -> class [39:12]
        |   |--IDENT -> FinalWrapper [39:18]
        |   `--OBJBLOCK -> OBJBLOCK [39:31]
        |       |--LCURLY -> { [39:31]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [40:9]
        |       |   |--MODIFIERS -> MODIFIERS [40:9]
        |       |   |   |--LITERAL_PUBLIC -> public [40:9]
        |       |   |   `--FINAL -> final [40:16]
        |       |   |--TYPE -> TYPE [40:22]
        |       |   |   `--IDENT -> AutoCloseable [40:22]
        |       |   |--IDENT -> finalField [40:36]
        |       |   |--ASSIGN -> = [40:47]
        |       |   |   `--EXPR -> EXPR [40:49]
        |       |   |       `--LITERAL_NEW -> new [40:49]
        |       |   |           |--IDENT -> AutoCloseable [40:53]
        |       |   |           |--LPAREN -> ( [40:66]
        |       |   |           |--ELIST -> ELIST [40:67]
        |       |   |           |--RPAREN -> ) [40:67]
        |       |   |           `--OBJBLOCK -> OBJBLOCK [40:69]
        |       |   |               |--LCURLY -> { [40:69]
        |       |   |               |--METHOD_DEF -> METHOD_DEF [41:13]
        |       |   |               |   |--MODIFIERS -> MODIFIERS [41:13]
        |       |   |               |   |   |--ANNOTATION -> ANNOTATION [41:13]
        |       |   |               |   |   |   |--AT -> @ [41:13]
        |       |   |               |   |   |   `--IDENT -> Override [41:14]
        |       |   |               |   |   `--LITERAL_PUBLIC -> public [42:13]
        |       |   |               |   |--TYPE -> TYPE [42:20]
        |       |   |               |   |   `--LITERAL_VOID -> void [42:20]
        |       |   |               |   |--IDENT -> close [42:25]
        |       |   |               |   |--LPAREN -> ( [42:30]
        |       |   |               |   |--PARAMETERS -> PARAMETERS [42:31]
        |       |   |               |   |--RPAREN -> ) [42:31]
        |       |   |               |   |--LITERAL_THROWS -> throws [42:33]
        |       |   |               |   |   `--IDENT -> Exception [42:40]
        |       |   |               |   `--SLIST -> { [42:50]
        |       |   |               |       `--RCURLY -> } [43:13]
        |       |   |               `--RCURLY -> } [44:9]
        |       |   `--SEMI -> ; [44:10]
        |       `--RCURLY -> } [45:5]
        |--METHOD_DEF -> METHOD_DEF [46:5]
        |   |--MODIFIERS -> MODIFIERS [46:5]
        |   |   |--ANNOTATION -> ANNOTATION [46:5]
        |   |   |   |--AT -> @ [46:5]
        |   |   |   `--IDENT -> Override [46:6]
        |   |   `--LITERAL_PUBLIC -> public [47:5]
        |   |--TYPE -> TYPE [47:12]
        |   |   `--LITERAL_VOID -> void [47:12]
        |   |--IDENT -> close [47:17]
        |   |--LPAREN -> ( [47:22]
        |   |--PARAMETERS -> PARAMETERS [47:23]
        |   |--RPAREN -> ) [47:23]
        |   |--LITERAL_THROWS -> throws [47:25]
        |   |   `--IDENT -> Exception [47:32]
        |   `--SLIST -> { [47:42]
        |       `--RCURLY -> } [48:5]
        `--RCURLY -> } [49:1]
