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