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