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 -> java25 [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 -> InputFlexibleConstructorBody [4:14]
|   `--OBJBLOCK -> OBJBLOCK [4:43]
|       |--LCURLY -> { [4:43]
|       |--CTOR_DEF -> CTOR_DEF [6:5]
|       |   |--MODIFIERS -> MODIFIERS [6:5]
|       |   |   `--LITERAL_PUBLIC -> public [6:5]
|       |   |--IDENT -> InputFlexibleConstructorBody [6:12]
|       |   |--LPAREN -> ( [6:40]
|       |   |--PARAMETERS -> PARAMETERS [6:41]
|       |   |--RPAREN -> ) [6:41]
|       |   `--SLIST -> { [6:43]
|       |       |--EXPR -> EXPR [7:27]
|       |       |   `--METHOD_CALL -> ( [7:27]
|       |       |       |--DOT -> . [7:19]
|       |       |       |   |--DOT -> . [7:15]
|       |       |       |   |   |--IDENT -> System [7:9]
|       |       |       |   |   `--IDENT -> out [7:16]
|       |       |       |   `--IDENT -> println [7:20]
|       |       |       |--ELIST -> ELIST [7:28]
|       |       |       |   `--EXPR -> EXPR [7:28]
|       |       |       |       `--STRING_LITERAL -> "hello" [7:28]
|       |       |       `--RPAREN -> ) [7:35]
|       |       |--SEMI -> ; [7:36]
|       |       |--SUPER_CTOR_CALL -> super [8:9]
|       |       |   |--LPAREN -> ( [8:14]
|       |       |   |--ELIST -> ELIST [8:15]
|       |       |   |--RPAREN -> ) [8:15]
|       |       |   `--SEMI -> ; [8:16]
|       |       `--RCURLY -> } [9:5]
|       `--RCURLY -> } [10:1]
|--CLASS_DEF -> CLASS_DEF [12:1]
|   |--MODIFIERS -> MODIFIERS [12:1]
|   |--LITERAL_CLASS -> class [12:1]
|   |--IDENT -> Jep512 [12:7]
|   `--OBJBLOCK -> OBJBLOCK [12:14]
|       |--LCURLY -> { [12:14]
|       |--VARIABLE_DEF -> VARIABLE_DEF [13:5]
|       |   |--MODIFIERS -> MODIFIERS [13:5]
|       |   |--TYPE -> TYPE [13:5]
|       |   |   `--LITERAL_INT -> int [13:5]
|       |   |--IDENT -> i [13:9]
|       |   `--SEMI -> ; [13:10]
|       |--VARIABLE_DEF -> VARIABLE_DEF [14:5]
|       |   |--MODIFIERS -> MODIFIERS [14:5]
|       |   |--TYPE -> TYPE [14:5]
|       |   |   |--IDENT -> String [14:5]
|       |   |   `--ARRAY_DECLARATOR -> [ [14:11]
|       |   |       `--RBRACK -> ] [14:12]
|       |   |--IDENT -> arr [14:14]
|       |   `--SEMI -> ; [14:17]
|       |--CTOR_DEF -> CTOR_DEF [16:5]
|       |   |--MODIFIERS -> MODIFIERS [16:5]
|       |   |--IDENT -> Jep512 [16:5]
|       |   |--LPAREN -> ( [16:11]
|       |   |--PARAMETERS -> PARAMETERS [16:12]
|       |   |--RPAREN -> ) [16:12]
|       |   `--SLIST -> { [16:14]
|       |       `--RCURLY -> } [17:5]
|       |--METHOD_DEF -> METHOD_DEF [19:5]
|       |   |--MODIFIERS -> MODIFIERS [19:5]
|       |   |   `--LITERAL_PUBLIC -> public [19:5]
|       |   |--TYPE -> TYPE [19:12]
|       |   |   `--LITERAL_INT -> int [19:12]
|       |   |--IDENT -> size [19:16]
|       |   |--LPAREN -> ( [19:20]
|       |   |--PARAMETERS -> PARAMETERS [19:21]
|       |   |--RPAREN -> ) [19:21]
|       |   `--SLIST -> { [19:23]
|       |       |--LITERAL_RETURN -> return [20:9]
|       |       |   |--EXPR -> EXPR [20:19]
|       |       |   |   `--DOT -> . [20:19]
|       |       |   |       |--IDENT -> arr [20:16]
|       |       |   |       `--IDENT -> length [20:20]
|       |       |   `--SEMI -> ; [20:26]
|       |       `--RCURLY -> } [21:5]
|       |--METHOD_DEF -> METHOD_DEF [23:5]
|       |   |--MODIFIERS -> MODIFIERS [23:5]
|       |   |   `--LITERAL_PUBLIC -> public [23:5]
|       |   |--TYPE -> TYPE [23:12]
|       |   |   `--LITERAL_BOOLEAN -> boolean [23:12]
|       |   |--IDENT -> isEmpty [23:20]
|       |   |--LPAREN -> ( [23:27]
|       |   |--PARAMETERS -> PARAMETERS [23:28]
|       |   |--RPAREN -> ) [23:28]
|       |   `--SLIST -> { [23:30]
|       |       |--LITERAL_RETURN -> return [24:9]
|       |       |   |--EXPR -> EXPR [24:27]
|       |       |   |   `--EQUAL -> == [24:27]
|       |       |   |       |--DOT -> . [24:19]
|       |       |   |       |   |--IDENT -> arr [24:16]
|       |       |   |       |   `--IDENT -> length [24:20]
|       |       |   |       `--NUM_INT -> 0 [24:30]
|       |       |   `--SEMI -> ; [24:31]
|       |       `--RCURLY -> } [25:5]
|       `--RCURLY -> } [26:1]
|--CLASS_DEF -> CLASS_DEF [28:1]
|   |--MODIFIERS -> MODIFIERS [28:1]
|   |--LITERAL_CLASS -> class [28:1]
|   |--IDENT -> Outer [28:7]
|   |--EXTENDS_CLAUSE -> extends [28:13]
|   |   `--IDENT -> Jep512 [28:21]
|   `--OBJBLOCK -> OBJBLOCK [28:28]
|       |--LCURLY -> { [28:28]
|       |--VARIABLE_DEF -> VARIABLE_DEF [30:5]
|       |   |--MODIFIERS -> MODIFIERS [30:5]
|       |   |--TYPE -> TYPE [30:5]
|       |   |   `--LITERAL_INT -> int [30:5]
|       |   |--IDENT -> i [30:9]
|       |   `--SEMI -> ; [30:10]
|       |--VARIABLE_DEF -> VARIABLE_DEF [31:5]
|       |   |--MODIFIERS -> MODIFIERS [31:5]
|       |   |--TYPE -> TYPE [31:5]
|       |   |   `--IDENT -> String [31:5]
|       |   |--IDENT -> s [31:12]
|       |   |--ASSIGN -> = [31:14]
|       |   |   `--EXPR -> EXPR [31:16]
|       |   |       `--STRING_LITERAL -> "hello" [31:16]
|       |   `--SEMI -> ; [31:23]
|       |--CTOR_DEF -> CTOR_DEF [33:5]
|       |   |--MODIFIERS -> MODIFIERS [33:5]
|       |   |--IDENT -> Outer [33:5]
|       |   |--LPAREN -> ( [33:10]
|       |   |--PARAMETERS -> PARAMETERS [33:11]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [33:11]
|       |   |       |--MODIFIERS -> MODIFIERS [33:11]
|       |   |       |--TYPE -> TYPE [33:11]
|       |   |       |   `--LITERAL_INT -> int [33:11]
|       |   |       `--IDENT -> number [33:15]
|       |   |--RPAREN -> ) [33:21]
|       |   `--SLIST -> { [33:23]
|       |       |--LITERAL_IF -> if [34:9]
|       |       |   |--LPAREN -> ( [34:12]
|       |       |   |--EXPR -> EXPR [34:20]
|       |       |   |   `--GT -> > [34:20]
|       |       |   |       |--IDENT -> number [34:13]
|       |       |   |       `--NUM_INT -> 0 [34:22]
|       |       |   |--RPAREN -> ) [34:23]
|       |       |   `--SLIST -> { [34:25]
|       |       |       |--LITERAL_THROW -> throw [35:13]
|       |       |       |   |--EXPR -> EXPR [35:19]
|       |       |       |   |   `--LITERAL_NEW -> new [35:19]
|       |       |       |   |       |--IDENT -> IllegalArgumentException [35:23]
|       |       |       |   |       |--LPAREN -> ( [35:47]
|       |       |       |   |       |--ELIST -> ELIST [35:48]
|       |       |       |   |       |   `--EXPR -> EXPR [35:48]
|       |       |       |   |       |       `--STRING_LITERAL -> "number must be positive" [35:48]
|       |       |       |   |       `--RPAREN -> ) [35:73]
|       |       |       |   `--SEMI -> ; [35:74]
|       |       |       `--RCURLY -> } [36:9]
|       |       |--EXPR -> EXPR [37:11]
|       |       |   `--ASSIGN -> = [37:11]
|       |       |       |--IDENT -> i [37:9]
|       |       |       `--IDENT -> number [37:13]
|       |       |--SEMI -> ; [37:19]
|       |       |--SUPER_CTOR_CALL -> super [38:9]
|       |       |   |--LPAREN -> ( [38:14]
|       |       |   |--ELIST -> ELIST [38:15]
|       |       |   |--RPAREN -> ) [38:15]
|       |       |   `--SEMI -> ; [38:16]
|       |       `--RCURLY -> } [39:5]
|       |--CTOR_DEF -> CTOR_DEF [41:5]
|       |   |--MODIFIERS -> MODIFIERS [41:5]
|       |   |--IDENT -> Outer [41:5]
|       |   |--LPAREN -> ( [41:10]
|       |   |--PARAMETERS -> PARAMETERS [41:11]
|       |   |--RPAREN -> ) [41:11]
|       |   `--SLIST -> { [41:13]
|       |       `--RCURLY -> } [41:14]
|       |--METHOD_DEF -> METHOD_DEF [43:5]
|       |   |--MODIFIERS -> MODIFIERS [43:5]
|       |   |   `--LITERAL_PUBLIC -> public [43:5]
|       |   |--TYPE -> TYPE [43:12]
|       |   |   `--LITERAL_INT -> int [43:12]
|       |   |--IDENT -> size [43:16]
|       |   |--LPAREN -> ( [43:20]
|       |   |--PARAMETERS -> PARAMETERS [43:21]
|       |   |--RPAREN -> ) [43:21]
|       |   `--SLIST -> { [43:23]
|       |       |--LITERAL_RETURN -> return [43:25]
|       |       |   |--EXPR -> EXPR [43:42]
|       |       |   |   `--METHOD_CALL -> ( [43:42]
|       |       |   |       |--DOT -> . [43:37]
|       |       |   |       |   |--LITERAL_SUPER -> super [43:32]
|       |       |   |       |   `--IDENT -> size [43:38]
|       |       |   |       |--ELIST -> ELIST [43:43]
|       |       |   |       `--RPAREN -> ) [43:43]
|       |       |   `--SEMI -> ; [43:44]
|       |       `--RCURLY -> } [43:46]
|       |--METHOD_DEF -> METHOD_DEF [45:5]
|       |   |--MODIFIERS -> MODIFIERS [45:5]
|       |   |   `--LITERAL_PUBLIC -> public [45:5]
|       |   |--TYPE -> TYPE [45:12]
|       |   |   `--LITERAL_BOOLEAN -> boolean [45:12]
|       |   |--IDENT -> isEmpty [45:20]
|       |   |--LPAREN -> ( [45:27]
|       |   |--PARAMETERS -> PARAMETERS [45:28]
|       |   |--RPAREN -> ) [45:28]
|       |   `--SLIST -> { [45:30]
|       |       |--LITERAL_RETURN -> return [45:32]
|       |       |   |--EXPR -> EXPR [45:58]
|       |       |   |   `--METHOD_CALL -> ( [45:58]
|       |       |   |       |--DOT -> . [45:50]
|       |       |   |       |   |--DOT -> . [45:44]
|       |       |   |       |   |   |--IDENT -> Outer [45:39]
|       |       |   |       |   |   `--LITERAL_SUPER -> super [45:45]
|       |       |   |       |   `--IDENT -> isEmpty [45:51]
|       |       |   |       |--ELIST -> ELIST [45:59]
|       |       |   |       `--RPAREN -> ) [45:59]
|       |       |   `--SEMI -> ; [45:60]
|       |       `--RCURLY -> } [45:62]
|       |--CLASS_DEF -> CLASS_DEF [47:5]
|       |   |--MODIFIERS -> MODIFIERS [47:5]
|       |   |--LITERAL_CLASS -> class [47:5]
|       |   |--IDENT -> Inner [47:11]
|       |   `--OBJBLOCK -> OBJBLOCK [47:17]
|       |       |--LCURLY -> { [47:17]
|       |       |--CTOR_DEF -> CTOR_DEF [48:9]
|       |       |   |--MODIFIERS -> MODIFIERS [48:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [48:9]
|       |       |   |--IDENT -> Inner [48:16]
|       |       |   |--LPAREN -> ( [48:21]
|       |       |   |--PARAMETERS -> PARAMETERS [48:22]
|       |       |   |--RPAREN -> ) [48:22]
|       |       |   `--SLIST -> { [48:24]
|       |       |       `--RCURLY -> } [49:9]
|       |       |--CTOR_DEF -> CTOR_DEF [51:9]
|       |       |   |--MODIFIERS -> MODIFIERS [51:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [51:9]
|       |       |   |--IDENT -> Inner [51:16]
|       |       |   |--LPAREN -> ( [51:21]
|       |       |   |--PARAMETERS -> PARAMETERS [51:22]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [51:22]
|       |       |   |       |--MODIFIERS -> MODIFIERS [51:22]
|       |       |   |       |--TYPE -> TYPE [51:22]
|       |       |   |       |   `--LITERAL_LONG -> long [51:22]
|       |       |   |       `--IDENT -> arg [51:27]
|       |       |   |--RPAREN -> ) [51:30]
|       |       |   `--SLIST -> { [51:32]
|       |       |       `--RCURLY -> } [52:9]
|       |       `--RCURLY -> } [53:5]
|       `--RCURLY -> } [54:1]
`--CLASS_DEF -> CLASS_DEF [56:1]
    |--MODIFIERS -> MODIFIERS [56:1]
    |--LITERAL_CLASS -> class [56:1]
    |--IDENT -> Derived [56:7]
    |--EXTENDS_CLAUSE -> extends [56:15]
    |   `--DOT -> . [56:28]
    |       |--IDENT -> Outer [56:23]
    |       `--IDENT -> Inner [56:29]
    `--OBJBLOCK -> OBJBLOCK [56:35]
        |--LCURLY -> { [56:35]
        |--CTOR_DEF -> CTOR_DEF [57:5]
        |   |--MODIFIERS -> MODIFIERS [57:5]
        |   |   `--LITERAL_PUBLIC -> public [57:5]
        |   |--IDENT -> Derived [57:12]
        |   |--LPAREN -> ( [57:19]
        |   |--PARAMETERS -> PARAMETERS [57:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [57:20]
        |   |       |--MODIFIERS -> MODIFIERS [57:20]
        |   |       |--TYPE -> TYPE [57:20]
        |   |       |   `--IDENT -> Outer [57:20]
        |   |       `--IDENT -> s [57:26]
        |   |--RPAREN -> ) [57:27]
        |   `--SLIST -> { [57:29]
        |       |--SUPER_CTOR_CALL -> super [59:11]
        |       |   |--IDENT -> s [59:9]
        |       |   |--DOT -> . [59:10]
        |       |   |--LPAREN -> ( [59:16]
        |       |   |--ELIST -> ELIST [59:17]
        |       |   |--RPAREN -> ) [59:17]
        |       |   `--SEMI -> ; [59:18]
        |       `--RCURLY -> } [60:5]
        |--CTOR_DEF -> CTOR_DEF [61:5]
        |   |--MODIFIERS -> MODIFIERS [61:5]
        |   |   `--LITERAL_PUBLIC -> public [61:5]
        |   |--IDENT -> Derived [61:12]
        |   |--LPAREN -> ( [61:19]
        |   |--PARAMETERS -> PARAMETERS [61:20]
        |   |--RPAREN -> ) [61:20]
        |   `--SLIST -> { [61:22]
        |       |--SUPER_CTOR_CALL -> super [63:21]
        |       |   |--LITERAL_NEW -> new [63:9]
        |       |   |   |--IDENT -> Outer [63:13]
        |       |   |   |--LPAREN -> ( [63:18]
        |       |   |   |--ELIST -> ELIST [63:19]
        |       |   |   `--RPAREN -> ) [63:19]
        |       |   |--DOT -> . [63:20]
        |       |   |--LPAREN -> ( [63:26]
        |       |   |--ELIST -> ELIST [63:27]
        |       |   |--RPAREN -> ) [63:27]
        |       |   `--SEMI -> ; [63:28]
        |       `--RCURLY -> } [64:5]
        |--CTOR_DEF -> CTOR_DEF [66:5]
        |   |--MODIFIERS -> MODIFIERS [66:5]
        |   |   `--LITERAL_PUBLIC -> public [66:5]
        |   |--IDENT -> Derived [66:12]
        |   |--LPAREN -> ( [66:19]
        |   |--PARAMETERS -> PARAMETERS [66:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:20]
        |   |       |--MODIFIERS -> MODIFIERS [66:20]
        |   |       |--TYPE -> TYPE [66:20]
        |   |       |   `--LITERAL_INT -> int [66:20]
        |   |       `--IDENT -> arg [66:24]
        |   |--RPAREN -> ) [66:27]
        |   `--SLIST -> { [66:29]
        |       |--SUPER_CTOR_CALL -> super [68:17]
        |       |   |--LITERAL_NEW -> new [68:5]
        |       |   |   |--IDENT -> Outer [68:9]
        |       |   |   |--LPAREN -> ( [68:14]
        |       |   |   |--ELIST -> ELIST [68:15]
        |       |   |   `--RPAREN -> ) [68:15]
        |       |   |--DOT -> . [68:16]
        |       |   |--LPAREN -> ( [68:22]
        |       |   |--ELIST -> ELIST [70:5]
        |       |   |   `--EXPR -> EXPR [70:5]
        |       |   |       `--PLUS -> + [70:5]
        |       |   |           |--IDENT -> arg [69:5]
        |       |   |           `--NUM_LONG -> 1L [70:7]
        |       |   |--RPAREN -> ) [70:9]
        |       |   `--SEMI -> ; [70:10]
        |       `--RCURLY -> } [71:5]
        `--RCURLY -> } [72:1]
