COMPILATION_UNIT -> COMPILATION_UNIT [1:0]
|--PACKAGE_DEF -> package [1:0]
|   |--ANNOTATIONS -> ANNOTATIONS [1:39]
|   |--DOT -> . [1:39]
|   |   |--DOT -> . [1:28]
|   |   |   |--DOT -> . [1:22]
|   |   |   |   |--DOT -> . [1:11]
|   |   |   |   |   |--IDENT -> com [1:8]
|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
|   |   |   |   `--IDENT -> tools [1:23]
|   |   |   `--IDENT -> checkstyle [1:29]
|   |   `--IDENT -> grammar [1:40]
|   `--SEMI -> ; [1:47]
|--IMPORT -> import [3:0]
|   |--DOT -> . [3:27]
|   |   |--DOT -> . [3:16]
|   |   |   |--DOT -> . [3:11]
|   |   |   |   |--IDENT -> java [3:7]
|   |   |   |   `--IDENT -> lang [3:12]
|   |   |   `--IDENT -> annotation [3:17]
|   |   `--IDENT -> ElementType [3:28]
|   `--SEMI -> ; [3:39]
|--IMPORT -> import [4:0]
|   |--DOT -> . [4:27]
|   |   |--DOT -> . [4:16]
|   |   |   |--DOT -> . [4:11]
|   |   |   |   |--IDENT -> java [4:7]
|   |   |   |   `--IDENT -> lang [4:12]
|   |   |   `--IDENT -> annotation [4:17]
|   |   `--IDENT -> Target [4:28]
|   `--SEMI -> ; [4:34]
|--IMPORT -> import [5:0]
|   |--DOT -> . [5:24]
|   |   |--DOT -> . [5:16]
|   |   |   |--DOT -> . [5:11]
|   |   |   |   |--IDENT -> java [5:7]
|   |   |   |   `--IDENT -> lang [5:12]
|   |   |   `--IDENT -> reflect [5:17]
|   |   `--IDENT -> InvocationTargetException [5:25]
|   `--SEMI -> ; [5:50]
|--IMPORT -> import [6:0]
|   |--DOT -> . [6:16]
|   |   |--DOT -> . [6:11]
|   |   |   |--IDENT -> java [6:7]
|   |   |   `--IDENT -> util [6:12]
|   |   `--IDENT -> List [6:17]
|   `--SEMI -> ; [6:21]
|--IMPORT -> import [8:0]
|   |--DOT -> . [8:23]
|   |   |--DOT -> . [8:12]
|   |   |   |--IDENT -> javax [8:7]
|   |   |   `--IDENT -> annotation [8:13]
|   |   `--IDENT -> Nullable [8:24]
|   `--SEMI -> ; [8:32]
|--IMPORT -> import [10:0]
|   |--DOT -> . [10:16]
|   |   |--DOT -> . [10:10]
|   |   |   |--IDENT -> org [10:7]
|   |   |   `--IDENT -> junit [10:11]
|   |   `--IDENT -> Assert [10:17]
|   `--SEMI -> ; [10:23]
|--IMPORT -> import [12:0]
|   |--DOT -> . [12:32]
|   |   |--DOT -> . [12:24]
|   |   |   |--DOT -> . [12:17]
|   |   |   |   |--DOT -> . [12:10]
|   |   |   |   |   |--IDENT -> com [12:7]
|   |   |   |   |   `--IDENT -> google [12:11]
|   |   |   |   `--IDENT -> common [12:18]
|   |   |   `--IDENT -> reflect [12:25]
|   |   `--IDENT -> Invokable [12:33]
|   `--SEMI -> ; [12:42]
|--CLASS_DEF -> CLASS_DEF [14:0]
|   |--MODIFIERS -> MODIFIERS [14:0]
|   |   `--LITERAL_PUBLIC -> public [14:0]
|   |--LITERAL_CLASS -> class [14:7]
|   |--IDENT -> InputAstRegressionAnnotatedMethodVariableArityParam [14:13]
|   `--OBJBLOCK -> OBJBLOCK [14:65]
|       |--LCURLY -> { [14:65]
|       |--METHOD_DEF -> METHOD_DEF [15:4]
|       |   |--MODIFIERS -> MODIFIERS [15:4]
|       |   |--TYPE -> TYPE [15:4]
|       |   |   `--LITERAL_VOID -> void [15:4]
|       |   |--IDENT -> varargLong [15:9]
|       |   |--LPAREN -> ( [15:19]
|       |   |--PARAMETERS -> PARAMETERS [15:20]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [15:20]
|       |   |       |--MODIFIERS -> MODIFIERS [15:20]
|       |   |       |   `--ANNOTATION -> ANNOTATION [15:20]
|       |   |       |       |--AT -> @ [15:20]
|       |   |       |       `--IDENT -> I [15:21]
|       |   |       |--TYPE -> TYPE [15:23]
|       |   |       |   |--IDENT -> String [15:23]
|       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [15:30]
|       |   |       |   |   `--ANNOTATION -> ANNOTATION [15:30]
|       |   |       |   |       |--AT -> @ [15:30]
|       |   |       |   |       `--IDENT -> L [15:31]
|       |   |       |   |--ARRAY_DECLARATOR -> [ [15:33]
|       |   |       |   |   `--RBRACK -> ] [15:34]
|       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [15:36]
|       |   |       |   |   `--ANNOTATION -> ANNOTATION [15:36]
|       |   |       |   |       |--AT -> @ [15:36]
|       |   |       |   |       `--IDENT -> K [15:37]
|       |   |       |   |--ARRAY_DECLARATOR -> [ [15:39]
|       |   |       |   |   `--RBRACK -> ] [15:40]
|       |   |       |   `--ANNOTATIONS -> ANNOTATIONS [15:42]
|       |   |       |       `--ANNOTATION -> ANNOTATION [15:42]
|       |   |       |           |--AT -> @ [15:42]
|       |   |       |           `--IDENT -> J [15:43]
|       |   |       |--ELLIPSIS -> ... [15:45]
|       |   |       `--IDENT -> vararg2 [15:49]
|       |   |--RPAREN -> ) [15:56]
|       |   `--SLIST -> { [15:58]
|       |       `--RCURLY -> } [15:60]
|       |--METHOD_DEF -> METHOD_DEF [16:4]
|       |   |--MODIFIERS -> MODIFIERS [16:4]
|       |   |   `--ANNOTATION -> ANNOTATION [16:4]
|       |   |       |--AT -> @ [16:4]
|       |   |       |--IDENT -> SuppressWarnings [16:5]
|       |   |       |--LPAREN -> ( [16:21]
|       |   |       |--EXPR -> EXPR [16:22]
|       |   |       |   `--STRING_LITERAL -> "unused" [16:22]
|       |   |       `--RPAREN -> ) [16:30]
|       |   |--TYPE -> TYPE [17:4]
|       |   |   `--LITERAL_VOID -> void [17:4]
|       |   |--IDENT -> withUpperBound [17:9]
|       |   |--LPAREN -> ( [17:23]
|       |   |--PARAMETERS -> PARAMETERS [17:24]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:24]
|       |   |       |--MODIFIERS -> MODIFIERS [17:24]
|       |   |       |--TYPE -> TYPE [17:24]
|       |   |       |   |--IDENT -> List [17:24]
|       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:28]
|       |   |       |       |--GENERIC_START -> < [17:28]
|       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:29]
|       |   |       |       |   |--WILDCARD_TYPE -> ? [17:29]
|       |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [17:31]
|       |   |       |       |       |--LITERAL_INT -> int [17:39]
|       |   |       |       |       |--ARRAY_DECLARATOR -> [ [17:42]
|       |   |       |       |       |   `--RBRACK -> ] [17:43]
|       |   |       |       |       `--ARRAY_DECLARATOR -> [ [17:44]
|       |   |       |       |           `--RBRACK -> ] [17:45]
|       |   |       |       `--GENERIC_END -> > [17:46]
|       |   |       `--IDENT -> list [17:48]
|       |   |--RPAREN -> ) [17:52]
|       |   `--SLIST -> { [17:54]
|       |       `--RCURLY -> } [17:55]
|       |--METHOD_DEF -> METHOD_DEF [18:4]
|       |   |--MODIFIERS -> MODIFIERS [18:4]
|       |   |   |--LITERAL_PRIVATE -> private [18:4]
|       |   |   `--LITERAL_STATIC -> static [18:12]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:19]
|       |   |   |--GENERIC_START -> < [18:19]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:20]
|       |   |   |   `--IDENT -> T [18:20]
|       |   |   `--GENERIC_END -> > [18:21]
|       |   |--TYPE -> TYPE [18:23]
|       |   |   |--ANNOTATIONS -> ANNOTATIONS [18:23]
|       |   |   |   `--ANNOTATION -> ANNOTATION [18:23]
|       |   |   |       |--AT -> @ [18:23]
|       |   |   |       `--IDENT -> Nullable [18:24]
|       |   |   `--IDENT -> T [18:33]
|       |   |--IDENT -> invoke [18:35]
|       |   |--LPAREN -> ( [18:41]
|       |   |--PARAMETERS -> PARAMETERS [18:42]
|       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [18:42]
|       |   |   |   |--MODIFIERS -> MODIFIERS [18:42]
|       |   |   |   |--TYPE -> TYPE [18:42]
|       |   |   |   |   |--IDENT -> Invokable [18:42]
|       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:51]
|       |   |   |   |       |--GENERIC_START -> < [18:51]
|       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:52]
|       |   |   |   |       |   `--WILDCARD_TYPE -> ? [18:52]
|       |   |   |   |       |--COMMA -> , [18:53]
|       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:55]
|       |   |   |   |       |   |--WILDCARD_TYPE -> ? [18:55]
|       |   |   |   |       |   `--TYPE_UPPER_BOUNDS -> extends [18:57]
|       |   |   |   |       |       `--IDENT -> T [18:65]
|       |   |   |   |       `--GENERIC_END -> > [18:66]
|       |   |   |   `--IDENT -> factory [18:68]
|       |   |   |--COMMA -> , [18:75]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [18:77]
|       |   |       |--MODIFIERS -> MODIFIERS [18:77]
|       |   |       |--TYPE -> TYPE [18:77]
|       |   |       |   |--IDENT -> List [18:77]
|       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:81]
|       |   |       |       |--GENERIC_START -> < [18:81]
|       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:82]
|       |   |       |       |   `--WILDCARD_TYPE -> ? [18:82]
|       |   |       |       `--GENERIC_END -> > [18:83]
|       |   |       `--IDENT -> args [18:85]
|       |   |--RPAREN -> ) [18:89]
|       |   |--LITERAL_THROWS -> throws [19:16]
|       |   |   |--IDENT -> InvocationTargetException [19:23]
|       |   |   |--COMMA -> , [19:48]
|       |   |   `--IDENT -> IllegalAccessException [19:50]
|       |   `--SLIST -> { [19:73]
|       |       |--LITERAL_RETURN -> return [20:12]
|       |       |   |--EXPR -> EXPR [20:19]
|       |       |   |   `--LITERAL_NULL -> null [20:19]
|       |       |   `--SEMI -> ; [20:23]
|       |       `--RCURLY -> } [21:8]
|       `--RCURLY -> } [22:0]
|--ANNOTATION_DEF -> ANNOTATION_DEF [23:0]
|   |--MODIFIERS -> MODIFIERS [23:0]
|   |   `--ANNOTATION -> ANNOTATION [23:0]
|   |       |--AT -> @ [23:0]
|   |       |--IDENT -> Target [23:1]
|   |       |--LPAREN -> ( [23:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [23:8]
|   |       |   |--EXPR -> EXPR [23:20]
|   |       |   |   `--DOT -> . [23:20]
|   |       |   |       |--IDENT -> ElementType [23:9]
|   |       |   |       `--IDENT -> TYPE_USE [23:21]
|   |       |   |--COMMA -> , [23:29]
|   |       |   |--EXPR -> EXPR [23:42]
|   |       |   |   `--DOT -> . [23:42]
|   |       |   |       |--IDENT -> ElementType [23:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [23:43]
|   |       |   `--RCURLY -> } [23:57]
|   |       `--RPAREN -> ) [23:58]
|   |--AT -> @ [24:0]
|   |--LITERAL_INTERFACE -> interface [24:1]
|   |--IDENT -> I [24:11]
|   `--OBJBLOCK -> OBJBLOCK [24:13]
|       |--LCURLY -> { [24:13]
|       `--RCURLY -> } [24:14]
|--ANNOTATION_DEF -> ANNOTATION_DEF [26:0]
|   |--MODIFIERS -> MODIFIERS [26:0]
|   |   `--ANNOTATION -> ANNOTATION [26:0]
|   |       |--AT -> @ [26:0]
|   |       |--IDENT -> Target [26:1]
|   |       |--LPAREN -> ( [26:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [26:8]
|   |       |   |--EXPR -> EXPR [26:20]
|   |       |   |   `--DOT -> . [26:20]
|   |       |   |       |--IDENT -> ElementType [26:9]
|   |       |   |       `--IDENT -> TYPE_USE [26:21]
|   |       |   |--COMMA -> , [26:29]
|   |       |   |--EXPR -> EXPR [26:42]
|   |       |   |   `--DOT -> . [26:42]
|   |       |   |       |--IDENT -> ElementType [26:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [26:43]
|   |       |   `--RCURLY -> } [26:57]
|   |       `--RPAREN -> ) [26:58]
|   |--AT -> @ [27:0]
|   |--LITERAL_INTERFACE -> interface [27:1]
|   |--IDENT -> J [27:11]
|   `--OBJBLOCK -> OBJBLOCK [27:13]
|       |--LCURLY -> { [27:13]
|       `--RCURLY -> } [27:14]
|--ANNOTATION_DEF -> ANNOTATION_DEF [29:0]
|   |--MODIFIERS -> MODIFIERS [29:0]
|   |   `--ANNOTATION -> ANNOTATION [29:0]
|   |       |--AT -> @ [29:0]
|   |       |--IDENT -> Target [29:1]
|   |       |--LPAREN -> ( [29:7]
|   |       |--ANNOTATION_ARRAY_INIT -> { [29:8]
|   |       |   |--EXPR -> EXPR [29:20]
|   |       |   |   `--DOT -> . [29:20]
|   |       |   |       |--IDENT -> ElementType [29:9]
|   |       |   |       `--IDENT -> TYPE_USE [29:21]
|   |       |   |--COMMA -> , [29:29]
|   |       |   |--EXPR -> EXPR [29:42]
|   |       |   |   `--DOT -> . [29:42]
|   |       |   |       |--IDENT -> ElementType [29:31]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [29:43]
|   |       |   `--RCURLY -> } [29:57]
|   |       `--RPAREN -> ) [29:58]
|   |--AT -> @ [30:0]
|   |--LITERAL_INTERFACE -> interface [30:1]
|   |--IDENT -> K [30:11]
|   `--OBJBLOCK -> OBJBLOCK [30:13]
|       |--LCURLY -> { [30:13]
|       `--RCURLY -> } [30:14]
`--ANNOTATION_DEF -> ANNOTATION_DEF [32:0]
    |--MODIFIERS -> MODIFIERS [32:0]
    |   `--ANNOTATION -> ANNOTATION [32:0]
    |       |--AT -> @ [32:0]
    |       |--IDENT -> Target [32:1]
    |       |--LPAREN -> ( [32:7]
    |       |--ANNOTATION_ARRAY_INIT -> { [32:8]
    |       |   |--EXPR -> EXPR [32:20]
    |       |   |   `--DOT -> . [32:20]
    |       |   |       |--IDENT -> ElementType [32:9]
    |       |   |       `--IDENT -> TYPE_USE [32:21]
    |       |   |--COMMA -> , [32:29]
    |       |   |--EXPR -> EXPR [32:42]
    |       |   |   `--DOT -> . [32:42]
    |       |   |       |--IDENT -> ElementType [32:31]
    |       |   |       `--IDENT -> TYPE_PARAMETER [32:43]
    |       |   `--RCURLY -> } [32:57]
    |       `--RPAREN -> ) [32:58]
    |--AT -> @ [33:0]
    |--LITERAL_INTERFACE -> interface [33:1]
    |--IDENT -> L [33:11]
    `--OBJBLOCK -> OBJBLOCK [33:13]
        |--LCURLY -> { [33:13]
        `--RCURLY -> } [33:14]
