COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:48]
|   |--DOT -> . [1:48]
|   |   |--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]
|   |   `--IDENT -> moduleinfo [1:49]
|   `--SEMI -> ; [1:59]
`--CLASS_DEF -> CLASS_DEF [4:1]
    |--MODIFIERS -> MODIFIERS [4:1]
    |   `--LITERAL_PUBLIC -> public [4:1]
    |--LITERAL_CLASS -> class [4:8]
    |--IDENT -> InputModuleKeywordsAsIdentifiers [4:14]
    `--OBJBLOCK -> OBJBLOCK [4:47]
        |--LCURLY -> { [4:47]
        |--VARIABLE_DEF -> VARIABLE_DEF [5:5]
        |   |--MODIFIERS -> MODIFIERS [5:5]
        |   |--TYPE -> TYPE [5:5]
        |   |   `--LITERAL_INT -> int [5:5]
        |   |--IDENT -> module [5:9]
        |   `--SEMI -> ; [5:15]
        |--VARIABLE_DEF -> VARIABLE_DEF [6:5]
        |   |--MODIFIERS -> MODIFIERS [6:5]
        |   |--TYPE -> TYPE [6:5]
        |   |   `--LITERAL_INT -> int [6:5]
        |   |--IDENT -> open [6:9]
        |   `--SEMI -> ; [6:13]
        |--VARIABLE_DEF -> VARIABLE_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |--TYPE -> TYPE [7:5]
        |   |   `--LITERAL_INT -> int [7:5]
        |   |--IDENT -> requires [7:9]
        |   `--SEMI -> ; [7:17]
        |--VARIABLE_DEF -> VARIABLE_DEF [8:5]
        |   |--MODIFIERS -> MODIFIERS [8:5]
        |   |--TYPE -> TYPE [8:5]
        |   |   `--LITERAL_INT -> int [8:5]
        |   |--IDENT -> transitive [8:9]
        |   `--SEMI -> ; [8:19]
        |--VARIABLE_DEF -> VARIABLE_DEF [9:5]
        |   |--MODIFIERS -> MODIFIERS [9:5]
        |   |--TYPE -> TYPE [9:5]
        |   |   `--LITERAL_INT -> int [9:5]
        |   |--IDENT -> exports [9:9]
        |   `--SEMI -> ; [9:16]
        |--VARIABLE_DEF -> VARIABLE_DEF [10:5]
        |   |--MODIFIERS -> MODIFIERS [10:5]
        |   |--TYPE -> TYPE [10:5]
        |   |   `--LITERAL_INT -> int [10:5]
        |   |--IDENT -> opens [10:9]
        |   `--SEMI -> ; [10:14]
        |--VARIABLE_DEF -> VARIABLE_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |--TYPE -> TYPE [11:5]
        |   |   `--LITERAL_INT -> int [11:5]
        |   |--IDENT -> to [11:9]
        |   `--SEMI -> ; [11:11]
        |--VARIABLE_DEF -> VARIABLE_DEF [12:5]
        |   |--MODIFIERS -> MODIFIERS [12:5]
        |   |--TYPE -> TYPE [12:5]
        |   |   `--LITERAL_INT -> int [12:5]
        |   |--IDENT -> uses [12:9]
        |   `--SEMI -> ; [12:13]
        |--VARIABLE_DEF -> VARIABLE_DEF [13:5]
        |   |--MODIFIERS -> MODIFIERS [13:5]
        |   |--TYPE -> TYPE [13:5]
        |   |   `--LITERAL_INT -> int [13:5]
        |   |--IDENT -> provides [13:9]
        |   `--SEMI -> ; [13:17]
        |--VARIABLE_DEF -> VARIABLE_DEF [14:5]
        |   |--MODIFIERS -> MODIFIERS [14:5]
        |   |--TYPE -> TYPE [14:5]
        |   |   `--LITERAL_INT -> int [14:5]
        |   |--IDENT -> with [14:9]
        |   `--SEMI -> ; [14:13]
        |--CLASS_DEF -> CLASS_DEF [16:5]
        |   |--MODIFIERS -> MODIFIERS [16:5]
        |   |   `--LITERAL_STATIC -> static [16:5]
        |   |--LITERAL_CLASS -> class [16:12]
        |   |--IDENT -> open [16:18]
        |   `--OBJBLOCK -> OBJBLOCK [16:23]
        |       |--LCURLY -> { [16:23]
        |       `--RCURLY -> } [16:25]
        |--CLASS_DEF -> CLASS_DEF [18:5]
        |   |--MODIFIERS -> MODIFIERS [18:5]
        |   |   `--LITERAL_STATIC -> static [18:5]
        |   |--LITERAL_CLASS -> class [18:12]
        |   |--IDENT -> to [18:18]
        |   `--OBJBLOCK -> OBJBLOCK [18:21]
        |       |--LCURLY -> { [18:21]
        |       `--RCURLY -> } [18:23]
        |--METHOD_DEF -> METHOD_DEF [20:5]
        |   |--MODIFIERS -> MODIFIERS [20:5]
        |   |--TYPE -> TYPE [20:5]
        |   |   `--LITERAL_VOID -> void [20:5]
        |   |--IDENT -> requires [20:10]
        |   |--LPAREN -> ( [20:18]
        |   |--PARAMETERS -> PARAMETERS [20:19]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [20:19]
        |   |       |--MODIFIERS -> MODIFIERS [20:19]
        |   |       |--TYPE -> TYPE [20:19]
        |   |       |   `--LITERAL_INT -> int [20:19]
        |   |       `--IDENT -> to [20:23]
        |   |--RPAREN -> ) [20:25]
        |   `--SLIST -> { [20:27]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [21:9]
        |       |   |--MODIFIERS -> MODIFIERS [21:9]
        |       |   |--TYPE -> TYPE [21:9]
        |       |   |   `--LITERAL_INT -> int [21:9]
        |       |   |--IDENT -> uses [21:13]
        |       |   `--ASSIGN -> = [21:18]
        |       |       `--EXPR -> EXPR [21:23]
        |       |           `--PLUS -> + [21:23]
        |       |               |--IDENT -> to [21:20]
        |       |               `--DOT -> . [21:29]
        |       |                   |--LITERAL_THIS -> this [21:25]
        |       |                   `--IDENT -> requires [21:30]
        |       |--SEMI -> ; [21:38]
        |       |--LABELED_STAT -> : [22:13]
        |       |   |--IDENT -> open [22:9]
        |       |   `--LITERAL_FOR -> for [22:15]
        |       |       |--LPAREN -> ( [22:19]
        |       |       |--FOR_INIT -> FOR_INIT [22:20]
        |       |       |   `--VARIABLE_DEF -> VARIABLE_DEF [22:20]
        |       |       |       |--MODIFIERS -> MODIFIERS [22:20]
        |       |       |       |--TYPE -> TYPE [22:20]
        |       |       |       |   `--LITERAL_INT -> int [22:20]
        |       |       |       |--IDENT -> i [22:24]
        |       |       |       `--ASSIGN -> = [22:26]
        |       |       |           `--EXPR -> EXPR [22:28]
        |       |       |               `--NUM_INT -> 0 [22:28]
        |       |       |--SEMI -> ; [22:29]
        |       |       |--FOR_CONDITION -> FOR_CONDITION [22:33]
        |       |       |   `--EXPR -> EXPR [22:33]
        |       |       |       `--LT -> < [22:33]
        |       |       |           |--IDENT -> i [22:31]
        |       |       |           `--IDENT -> to [22:35]
        |       |       |--SEMI -> ; [22:37]
        |       |       |--FOR_ITERATOR -> FOR_ITERATOR [22:40]
        |       |       |   `--ELIST -> ELIST [22:40]
        |       |       |       `--EXPR -> EXPR [22:40]
        |       |       |           `--POST_INC -> ++ [22:40]
        |       |       |               `--IDENT -> i [22:39]
        |       |       |--RPAREN -> ) [22:42]
        |       |       `--SLIST -> { [22:44]
        |       |           |--LITERAL_IF -> if [23:13]
        |       |           |   |--LPAREN -> ( [23:16]
        |       |           |   |--EXPR -> EXPR [23:22]
        |       |           |   |   `--GT -> > [23:22]
        |       |           |   |       |--IDENT -> uses [23:17]
        |       |           |   |       `--NUM_INT -> 0 [23:24]
        |       |           |   |--RPAREN -> ) [23:25]
        |       |           |   `--SLIST -> { [23:27]
        |       |           |       |--LITERAL_BREAK -> break [24:17]
        |       |           |       |   |--IDENT -> open [24:23]
        |       |           |       |   `--SEMI -> ; [24:27]
        |       |           |       `--RCURLY -> } [25:13]
        |       |           `--RCURLY -> } [26:9]
        |       |--EXPR -> EXPR [27:19]
        |       |   `--METHOD_CALL -> ( [27:19]
        |       |       |--IDENT -> transitive [27:9]
        |       |       |--ELIST -> ELIST [27:20]
        |       |       `--RPAREN -> ) [27:20]
        |       |--SEMI -> ; [27:21]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [28:27]
        |       |   |--MODIFIERS -> MODIFIERS [28:27]
        |       |   |--TYPE -> TYPE [28:27]
        |       |   |   `--DOT -> . [28:27]
        |       |   |       |--DOT -> . [28:18]
        |       |   |       |   |--DOT -> . [28:13]
        |       |   |       |   |   |--IDENT -> java [28:9]
        |       |   |       |   |   `--IDENT -> util [28:14]
        |       |   |       |   `--IDENT -> function [28:19]
        |       |   |       |--IDENT -> Supplier [28:28]
        |       |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [28:36]
        |       |   |           |--GENERIC_START -> < [28:36]
        |       |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [28:37]
        |       |   |           |   `--IDENT -> String [28:37]
        |       |   |           `--GENERIC_END -> > [28:43]
        |       |   |--IDENT -> s [28:45]
        |       |   `--ASSIGN -> = [28:47]
        |       |       `--EXPR -> EXPR [28:53]
        |       |           `--METHOD_REF -> :: [28:53]
        |       |               |--LITERAL_THIS -> this [28:49]
        |       |               `--IDENT -> provides [28:55]
        |       |--SEMI -> ; [28:63]
        |       `--RCURLY -> } [29:5]
        |--METHOD_DEF -> METHOD_DEF [31:5]
        |   |--MODIFIERS -> MODIFIERS [31:5]
        |   |--TYPE -> TYPE [31:5]
        |   |   `--LITERAL_VOID -> void [31:5]
        |   |--IDENT -> transitive [31:10]
        |   |--LPAREN -> ( [31:20]
        |   |--PARAMETERS -> PARAMETERS [31:21]
        |   |--RPAREN -> ) [31:21]
        |   `--SLIST -> { [31:23]
        |       |--EXPR -> EXPR [32:13]
        |       |   `--METHOD_CALL -> ( [32:13]
        |       |       |--IDENT -> with [32:9]
        |       |       |--ELIST -> ELIST [32:14]
        |       |       |   |--EXPR -> EXPR [32:14]
        |       |       |   |   `--IDENT -> module [32:14]
        |       |       |   |--COMMA -> , [32:20]
        |       |       |   `--EXPR -> EXPR [32:22]
        |       |       |       `--IDENT -> open [32:22]
        |       |       `--RPAREN -> ) [32:26]
        |       |--SEMI -> ; [32:27]
        |       `--RCURLY -> } [33:5]
        |--METHOD_DEF -> METHOD_DEF [35:5]
        |   |--MODIFIERS -> MODIFIERS [35:5]
        |   |--TYPE -> TYPE [35:5]
        |   |   `--LITERAL_VOID -> void [35:5]
        |   |--IDENT -> with [35:10]
        |   |--LPAREN -> ( [35:14]
        |   |--PARAMETERS -> PARAMETERS [35:15]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [35:15]
        |   |   |   |--MODIFIERS -> MODIFIERS [35:15]
        |   |   |   |--TYPE -> TYPE [35:15]
        |   |   |   |   `--LITERAL_INT -> int [35:15]
        |   |   |   `--IDENT -> a [35:19]
        |   |   |--COMMA -> , [35:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [35:22]
        |   |       |--MODIFIERS -> MODIFIERS [35:22]
        |   |       |--TYPE -> TYPE [35:22]
        |   |       |   `--LITERAL_INT -> int [35:22]
        |   |       `--IDENT -> b [35:26]
        |   |--RPAREN -> ) [35:27]
        |   `--SLIST -> { [35:29]
        |       `--RCURLY -> } [35:31]
        |--METHOD_DEF -> METHOD_DEF [37:5]
        |   |--MODIFIERS -> MODIFIERS [37:5]
        |   |--TYPE -> TYPE [37:5]
        |   |   `--IDENT -> String [37:5]
        |   |--IDENT -> provides [37:12]
        |   |--LPAREN -> ( [37:20]
        |   |--PARAMETERS -> PARAMETERS [37:21]
        |   |--RPAREN -> ) [37:21]
        |   `--SLIST -> { [37:23]
        |       |--LITERAL_RETURN -> return [38:9]
        |       |   |--EXPR -> EXPR [38:16]
        |       |   |   `--STRING_LITERAL -> "provides" [38:16]
        |       |   `--SEMI -> ; [38:26]
        |       `--RCURLY -> } [39:5]
        |--METHOD_DEF -> METHOD_DEF [41:5]
        |   |--MODIFIERS -> MODIFIERS [41:5]
        |   |--TYPE -> TYPE [41:5]
        |   |   `--LITERAL_INT -> int [41:5]
        |   |--IDENT -> uses [41:9]
        |   |--LPAREN -> ( [41:13]
        |   |--PARAMETERS -> PARAMETERS [41:14]
        |   |   |--PARAMETER_DEF -> PARAMETER_DEF [41:14]
        |   |   |   |--MODIFIERS -> MODIFIERS [41:14]
        |   |   |   |--TYPE -> TYPE [41:14]
        |   |   |   |   `--IDENT -> open [41:14]
        |   |   |   `--IDENT -> o [41:19]
        |   |   |--COMMA -> , [41:20]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [41:22]
        |   |       |--MODIFIERS -> MODIFIERS [41:22]
        |   |       |--TYPE -> TYPE [41:22]
        |   |       |   `--IDENT -> to [41:22]
        |   |       `--IDENT -> t [41:25]
        |   |--RPAREN -> ) [41:26]
        |   `--SLIST -> { [41:28]
        |       |--LITERAL_RETURN -> return [42:9]
        |       |   |--EXPR -> EXPR [42:36]
        |       |   |   `--PLUS -> + [42:36]
        |       |   |       |--METHOD_CALL -> ( [42:33]
        |       |   |       |   |--DOT -> . [42:24]
        |       |   |       |   |   |--DOT -> . [42:18]
        |       |   |       |   |   |   |--IDENT -> to [42:16]
        |       |   |       |   |   |   `--LITERAL_CLASS -> class [42:19]
        |       |   |       |   |   `--IDENT -> hashCode [42:25]
        |       |   |       |   |--ELIST -> ELIST [42:34]
        |       |   |       |   `--RPAREN -> ) [42:34]
        |       |   |       `--METHOD_CALL -> ( [42:57]
        |       |   |           |--DOT -> . [42:48]
        |       |   |           |   |--DOT -> . [42:42]
        |       |   |           |   |   |--IDENT -> open [42:38]
        |       |   |           |   |   `--LITERAL_CLASS -> class [42:43]
        |       |   |           |   `--IDENT -> hashCode [42:49]
        |       |   |           |--ELIST -> ELIST [42:58]
        |       |   |           `--RPAREN -> ) [42:58]
        |       |   `--SEMI -> ; [42:59]
        |       `--RCURLY -> } [43:5]
        `--RCURLY -> } [44:1]
