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 -> antlr4 [1:49]
|   `--SEMI -> ; [1:55]
|--STATIC_IMPORT -> import [3:1]
|   |--LITERAL_STATIC -> static [3:8]
|   |--DOT -> . [3:47]
|   |   |--DOT -> . [3:35]
|   |   |   |--DOT -> . [3:24]
|   |   |   |   |--DOT -> . [3:19]
|   |   |   |   |   |--IDENT -> java [3:15]
|   |   |   |   |   `--IDENT -> lang [3:20]
|   |   |   |   `--IDENT -> annotation [3:25]
|   |   |   `--IDENT -> ElementType [3:36]
|   |   `--IDENT -> TYPE_USE [3:48]
|   `--SEMI -> ; [3:56]
|--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 -> Retention [5:29]
|   `--SEMI -> ; [5:38]
|--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 -> RetentionPolicy [6:29]
|   `--SEMI -> ; [6:44]
|--IMPORT -> import [7:1]
|   |--DOT -> . [7:28]
|   |   |--DOT -> . [7:17]
|   |   |   |--DOT -> . [7:12]
|   |   |   |   |--IDENT -> java [7:8]
|   |   |   |   `--IDENT -> lang [7:13]
|   |   |   `--IDENT -> annotation [7:18]
|   |   `--IDENT -> Target [7:29]
|   `--SEMI -> ; [7:35]
`--CLASS_DEF -> CLASS_DEF [9:1]
    |--MODIFIERS -> MODIFIERS [9:1]
    |   `--LITERAL_PUBLIC -> public [9:1]
    |--LITERAL_CLASS -> class [9:8]
    |--IDENT -> InputAntlr4AstRegressionAnnotationOnArrays [9:14]
    `--OBJBLOCK -> OBJBLOCK [9:57]
        |--LCURLY -> { [9:57]
        |--VARIABLE_DEF -> VARIABLE_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |   `--LITERAL_PRIVATE -> private [11:5]
        |   |--TYPE -> TYPE [11:13]
        |   |   |--IDENT -> String [11:13]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [11:27]
        |   |   |   `--ANNOTATION -> ANNOTATION [11:27]
        |   |   |       |--AT -> @ [11:27]
        |   |   |       `--IDENT -> Nullable [11:28]
        |   |   `--ARRAY_DECLARATOR -> [ [11:37]
        |   |       `--RBRACK -> ] [11:38]
        |   |--IDENT -> array1 [11:20]
        |   `--SEMI -> ; [11:39]
        |--VARIABLE_DEF -> VARIABLE_DEF [12:5]
        |   |--MODIFIERS -> MODIFIERS [12:5]
        |   |   |--LITERAL_PRIVATE -> private [12:5]
        |   |   `--ANNOTATION -> ANNOTATION [12:13]
        |   |       |--AT -> @ [12:13]
        |   |       `--IDENT -> Nullable [12:14]
        |   |--TYPE -> TYPE [12:23]
        |   |   |--LITERAL_INT -> int [12:23]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [12:34]
        |   |   |   `--ANNOTATION -> ANNOTATION [12:34]
        |   |   |       |--AT -> @ [12:34]
        |   |   |       `--IDENT -> Nullable [12:35]
        |   |   |--ARRAY_DECLARATOR -> [ [12:44]
        |   |   |   `--RBRACK -> ] [12:45]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [12:47]
        |   |   |   `--ANNOTATION -> ANNOTATION [12:47]
        |   |   |       |--AT -> @ [12:47]
        |   |   |       `--IDENT -> Nullable [12:48]
        |   |   `--ARRAY_DECLARATOR -> [ [12:57]
        |   |       `--RBRACK -> ] [12:58]
        |   |--IDENT -> array2 [12:27]
        |   `--SEMI -> ; [12:59]
        |--CTOR_DEF -> CTOR_DEF [14:5]
        |   |--MODIFIERS -> MODIFIERS [14:5]
        |   |   `--LITERAL_PRIVATE -> private [14:5]
        |   |--IDENT -> InputAntlr4AstRegressionAnnotationOnArrays [14:13]
        |   |--LPAREN -> ( [14:55]
        |   |--PARAMETERS -> PARAMETERS [14:56]
        |   |--RPAREN -> ) [14:56]
        |   `--SLIST -> { [14:58]
        |       `--RCURLY -> } [15:5]
        |--METHOD_DEF -> METHOD_DEF [17:5]
        |   |--MODIFIERS -> MODIFIERS [17:5]
        |   |   |--LITERAL_PUBLIC -> public [17:5]
        |   |   `--LITERAL_STATIC -> static [17:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [17:19]
        |   |   |--GENERIC_START -> < [17:19]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [17:20]
        |   |   |   `--IDENT -> T [17:20]
        |   |   `--GENERIC_END -> > [17:21]
        |   |--TYPE -> TYPE [17:23]
        |   |   |--IDENT -> T [17:23]
        |   |   `--ARRAY_DECLARATOR -> [ [17:24]
        |   |       `--RBRACK -> ] [17:25]
        |   |--IDENT -> checkNotNullContents [17:27]
        |   |--LPAREN -> ( [17:47]
        |   |--PARAMETERS -> PARAMETERS [17:48]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:48]
        |   |       |--MODIFIERS -> MODIFIERS [17:48]
        |   |       |--TYPE -> TYPE [17:48]
        |   |       |   |--IDENT -> T [17:48]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [17:50]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [17:50]
        |   |       |   |       |--AT -> @ [17:50]
        |   |       |   |       `--IDENT -> Nullable [17:51]
        |   |       |   `--ARRAY_DECLARATOR -> [ [17:60]
        |   |       |       `--RBRACK -> ] [17:61]
        |   |       `--IDENT -> array [17:63]
        |   |--RPAREN -> ) [17:68]
        |   `--SLIST -> { [17:70]
        |       |--LITERAL_IF -> if [18:9]
        |       |   |--LPAREN -> ( [18:12]
        |       |   |--EXPR -> EXPR [18:19]
        |       |   |   `--EQUAL -> == [18:19]
        |       |   |       |--IDENT -> array [18:13]
        |       |   |       `--LITERAL_NULL -> null [18:22]
        |       |   |--RPAREN -> ) [18:26]
        |       |   `--SLIST -> { [18:28]
        |       |       |--LITERAL_THROW -> throw [19:13]
        |       |       |   |--EXPR -> EXPR [19:19]
        |       |       |   |   `--LITERAL_NEW -> new [19:19]
        |       |       |   |       |--IDENT -> NullPointerException [19:23]
        |       |       |   |       |--LPAREN -> ( [19:43]
        |       |       |   |       |--ELIST -> ELIST [19:44]
        |       |       |   |       `--RPAREN -> ) [19:44]
        |       |       |   `--SEMI -> ; [19:45]
        |       |       `--RCURLY -> } [20:9]
        |       |--LITERAL_RETURN -> return [22:9]
        |       |   |--EXPR -> EXPR [22:16]
        |       |   |   `--IDENT -> array [22:16]
        |       |   `--SEMI -> ; [22:21]
        |       `--RCURLY -> } [23:5]
        |--METHOD_DEF -> METHOD_DEF [25:5]
        |   |--MODIFIERS -> MODIFIERS [25:5]
        |   |   |--LITERAL_PUBLIC -> public [25:5]
        |   |   `--LITERAL_STATIC -> static [25:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [25:19]
        |   |   |--GENERIC_START -> < [25:19]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [25:20]
        |   |   |   `--IDENT -> T [25:20]
        |   |   `--GENERIC_END -> > [25:21]
        |   |--TYPE -> TYPE [25:23]
        |   |   |--IDENT -> T [25:23]
        |   |   |--ARRAY_DECLARATOR -> [ [25:24]
        |   |   |   `--RBRACK -> ] [25:25]
        |   |   `--ARRAY_DECLARATOR -> [ [25:26]
        |   |       `--RBRACK -> ] [25:27]
        |   |--IDENT -> checkNotNullContents2 [25:29]
        |   |--LPAREN -> ( [25:50]
        |   |--PARAMETERS -> PARAMETERS [25:51]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:51]
        |   |       |--MODIFIERS -> MODIFIERS [25:51]
        |   |       |--TYPE -> TYPE [25:51]
        |   |       |   |--IDENT -> T [25:51]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:53]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [25:53]
        |   |       |   |       |--AT -> @ [25:53]
        |   |       |   |       `--IDENT -> Nullable [25:54]
        |   |       |   |--ARRAY_DECLARATOR -> [ [25:63]
        |   |       |   |   `--RBRACK -> ] [25:64]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:66]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [25:66]
        |   |       |   |       |--AT -> @ [25:66]
        |   |       |   |       `--IDENT -> Nullable [25:67]
        |   |       |   `--ARRAY_DECLARATOR -> [ [25:76]
        |   |       |       `--RBRACK -> ] [25:77]
        |   |       `--IDENT -> array [25:79]
        |   |--RPAREN -> ) [25:84]
        |   `--SLIST -> { [25:86]
        |       |--LITERAL_IF -> if [26:9]
        |       |   |--LPAREN -> ( [26:12]
        |       |   |--EXPR -> EXPR [26:19]
        |       |   |   `--EQUAL -> == [26:19]
        |       |   |       |--IDENT -> array [26:13]
        |       |   |       `--LITERAL_NULL -> null [26:22]
        |       |   |--RPAREN -> ) [26:26]
        |       |   `--SLIST -> { [26:28]
        |       |       |--LITERAL_THROW -> throw [27:13]
        |       |       |   |--EXPR -> EXPR [27:19]
        |       |       |   |   `--LITERAL_NEW -> new [27:19]
        |       |       |   |       |--IDENT -> NullPointerException [27:23]
        |       |       |   |       |--LPAREN -> ( [27:43]
        |       |       |   |       |--ELIST -> ELIST [27:44]
        |       |       |   |       `--RPAREN -> ) [27:44]
        |       |       |   `--SEMI -> ; [27:45]
        |       |       `--RCURLY -> } [28:9]
        |       |--LITERAL_RETURN -> return [30:9]
        |       |   |--EXPR -> EXPR [30:16]
        |       |   |   `--IDENT -> array [30:16]
        |       |   `--SEMI -> ; [30:21]
        |       `--RCURLY -> } [31:5]
        |--METHOD_DEF -> METHOD_DEF [33:5]
        |   |--MODIFIERS -> MODIFIERS [33:5]
        |   |   |--LITERAL_PUBLIC -> public [33:5]
        |   |   `--LITERAL_STATIC -> static [33:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [33:19]
        |   |   |--GENERIC_START -> < [33:19]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [33:20]
        |   |   |   `--IDENT -> T [33:20]
        |   |   `--GENERIC_END -> > [33:21]
        |   |--TYPE -> TYPE [33:23]
        |   |   |--IDENT -> T [33:23]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [33:25]
        |   |   |   `--ANNOTATION -> ANNOTATION [33:25]
        |   |   |       |--AT -> @ [33:25]
        |   |   |       `--IDENT -> Nullable [33:26]
        |   |   `--ARRAY_DECLARATOR -> [ [33:35]
        |   |       `--RBRACK -> ] [33:36]
        |   |--IDENT -> checkNotNullContents3 [33:38]
        |   |--LPAREN -> ( [33:59]
        |   |--PARAMETERS -> PARAMETERS [33:60]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [33:60]
        |   |       |--MODIFIERS -> MODIFIERS [33:60]
        |   |       |--TYPE -> TYPE [33:60]
        |   |       |   |--IDENT -> T [33:60]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [33:68]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [33:68]
        |   |       |   |       |--AT -> @ [33:68]
        |   |       |   |       `--IDENT -> Nullable [33:69]
        |   |       |   `--ARRAY_DECLARATOR -> [ [33:78]
        |   |       |       `--RBRACK -> ] [33:79]
        |   |       `--IDENT -> array [33:62]
        |   |--RPAREN -> ) [33:80]
        |   `--SLIST -> { [33:82]
        |       |--LITERAL_IF -> if [34:9]
        |       |   |--LPAREN -> ( [34:12]
        |       |   |--EXPR -> EXPR [34:19]
        |       |   |   `--EQUAL -> == [34:19]
        |       |   |       |--IDENT -> array [34:13]
        |       |   |       `--LITERAL_NULL -> null [34:22]
        |       |   |--RPAREN -> ) [34:26]
        |       |   `--SLIST -> { [34:28]
        |       |       |--LITERAL_THROW -> throw [35:13]
        |       |       |   |--EXPR -> EXPR [35:19]
        |       |       |   |   `--LITERAL_NEW -> new [35:19]
        |       |       |   |       |--IDENT -> NullPointerException [35:23]
        |       |       |   |       |--LPAREN -> ( [35:43]
        |       |       |   |       |--ELIST -> ELIST [35:44]
        |       |       |   |       `--RPAREN -> ) [35:44]
        |       |       |   `--SEMI -> ; [35:45]
        |       |       `--RCURLY -> } [36:9]
        |       |--LITERAL_RETURN -> return [38:9]
        |       |   |--EXPR -> EXPR [38:16]
        |       |   |   `--IDENT -> array [38:16]
        |       |   `--SEMI -> ; [38:21]
        |       `--RCURLY -> } [39:5]
        |--METHOD_DEF -> METHOD_DEF [41:5]
        |   |--MODIFIERS -> MODIFIERS [41:5]
        |   |   `--LITERAL_PUBLIC -> public [41:5]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [41:12]
        |   |   |--GENERIC_START -> < [41:12]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [41:13]
        |   |   |   `--IDENT -> T [41:13]
        |   |   `--GENERIC_END -> > [41:14]
        |   |--TYPE -> TYPE [41:16]
        |   |   |--IDENT -> T [41:16]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [41:62]
        |   |   |   `--ANNOTATION -> ANNOTATION [41:62]
        |   |   |       |--AT -> @ [41:62]
        |   |   |       `--IDENT -> Nullable [41:63]
        |   |   `--ARRAY_DECLARATOR -> [ [41:72]
        |   |       `--RBRACK -> ] [41:73]
        |   |--IDENT -> checkNotNullContents4 [41:18]
        |   |--LPAREN -> ( [41:39]
        |   |--PARAMETERS -> PARAMETERS [41:40]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [41:40]
        |   |       |--MODIFIERS -> MODIFIERS [41:40]
        |   |       |--TYPE -> TYPE [41:40]
        |   |       |   |--IDENT -> T [41:40]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [41:42]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [41:42]
        |   |       |   |       |--AT -> @ [41:42]
        |   |       |   |       `--IDENT -> Nullable [41:43]
        |   |       |   `--ARRAY_DECLARATOR -> [ [41:52]
        |   |       |       `--RBRACK -> ] [41:53]
        |   |       `--IDENT -> array [41:55]
        |   |--RPAREN -> ) [41:60]
        |   `--SLIST -> { [41:75]
        |       |--LITERAL_IF -> if [42:9]
        |       |   |--LPAREN -> ( [42:12]
        |       |   |--EXPR -> EXPR [42:19]
        |       |   |   `--EQUAL -> == [42:19]
        |       |   |       |--IDENT -> array [42:13]
        |       |   |       `--LITERAL_NULL -> null [42:22]
        |       |   |--RPAREN -> ) [42:26]
        |       |   `--SLIST -> { [42:28]
        |       |       |--LITERAL_THROW -> throw [43:13]
        |       |       |   |--EXPR -> EXPR [43:19]
        |       |       |   |   `--LITERAL_NEW -> new [43:19]
        |       |       |   |       |--IDENT -> NullPointerException [43:23]
        |       |       |   |       |--LPAREN -> ( [43:43]
        |       |       |   |       |--ELIST -> ELIST [43:44]
        |       |       |   |       `--RPAREN -> ) [43:44]
        |       |       |   `--SEMI -> ; [43:45]
        |       |       `--RCURLY -> } [44:9]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [45:9]
        |       |   |--MODIFIERS -> MODIFIERS [45:9]
        |       |   |--TYPE -> TYPE [45:9]
        |       |   |   |--IDENT -> String [45:9]
        |       |   |   |--ANNOTATIONS -> ANNOTATIONS [45:21]
        |       |   |   |   `--ANNOTATION -> ANNOTATION [45:21]
        |       |   |   |       |--AT -> @ [45:21]
        |       |   |   |       `--IDENT -> Nullable [45:22]
        |       |   |   `--ARRAY_DECLARATOR -> [ [45:31]
        |       |   |       `--RBRACK -> ] [45:32]
        |       |   `--IDENT -> tmp1 [45:16]
        |       |--SEMI -> ; [45:33]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [46:9]
        |       |   |--MODIFIERS -> MODIFIERS [46:9]
        |       |   |   `--ANNOTATION -> ANNOTATION [46:9]
        |       |   |       |--AT -> @ [46:9]
        |       |   |       `--IDENT -> Nullable [46:10]
        |       |   |--TYPE -> TYPE [46:19]
        |       |   |   |--IDENT -> Object [46:19]
        |       |   |   `--ARRAY_DECLARATOR -> [ [46:25]
        |       |   |       `--RBRACK -> ] [46:26]
        |       |   |--IDENT -> tmp2 [46:28]
        |       |   `--ASSIGN -> = [46:33]
        |       |       `--EXPR -> EXPR [46:35]
        |       |           `--LITERAL_NEW -> new [46:35]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [46:39]
        |       |               |   `--ANNOTATION -> ANNOTATION [46:39]
        |       |               |       |--AT -> @ [46:39]
        |       |               |       `--IDENT -> Nullable [46:40]
        |       |               |--IDENT -> Integer [46:49]
        |       |               `--ARRAY_DECLARATOR -> [ [46:56]
        |       |                   |--EXPR -> EXPR [46:57]
        |       |                   |   `--NUM_INT -> 3 [46:57]
        |       |                   `--RBRACK -> ] [46:58]
        |       |--SEMI -> ; [46:59]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [47:9]
        |       |   |--MODIFIERS -> MODIFIERS [47:9]
        |       |   |   `--ANNOTATION -> ANNOTATION [47:9]
        |       |   |       |--AT -> @ [47:9]
        |       |   |       `--IDENT -> Nullable [47:10]
        |       |   |--TYPE -> TYPE [47:19]
        |       |   |   |--LITERAL_INT -> int [47:19]
        |       |   |   `--ARRAY_DECLARATOR -> [ [47:22]
        |       |   |       `--RBRACK -> ] [47:23]
        |       |   |--IDENT -> tmp3 [47:25]
        |       |   `--ASSIGN -> = [47:30]
        |       |       `--EXPR -> EXPR [47:32]
        |       |           `--LITERAL_NEW -> new [47:32]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [47:36]
        |       |               |   `--ANNOTATION -> ANNOTATION [47:36]
        |       |               |       |--AT -> @ [47:36]
        |       |               |       `--IDENT -> Nullable [47:37]
        |       |               |--LITERAL_INT -> int [47:46]
        |       |               `--ARRAY_DECLARATOR -> [ [47:49]
        |       |                   |--EXPR -> EXPR [47:50]
        |       |                   |   `--NUM_INT -> 3 [47:50]
        |       |                   `--RBRACK -> ] [47:51]
        |       |--SEMI -> ; [47:52]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [48:9]
        |       |   |--MODIFIERS -> MODIFIERS [48:9]
        |       |   |   `--ANNOTATION -> ANNOTATION [48:9]
        |       |   |       |--AT -> @ [48:9]
        |       |   |       `--IDENT -> Nullable [48:10]
        |       |   |--TYPE -> TYPE [48:19]
        |       |   |   `--IDENT -> Object [48:19]
        |       |   |--IDENT -> tmp4 [48:26]
        |       |   `--ASSIGN -> = [48:31]
        |       |       `--EXPR -> EXPR [48:33]
        |       |           `--LITERAL_NEW -> new [48:33]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [48:37]
        |       |               |   `--ANNOTATION -> ANNOTATION [48:37]
        |       |               |       |--AT -> @ [48:37]
        |       |               |       `--IDENT -> Nullable [48:38]
        |       |               |--IDENT -> String [48:47]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [48:54]
        |       |               |   `--ANNOTATION -> ANNOTATION [48:54]
        |       |               |       |--AT -> @ [48:54]
        |       |               |       `--IDENT -> Nullable [48:55]
        |       |               |--ARRAY_DECLARATOR -> [ [48:64]
        |       |               |   |--EXPR -> EXPR [48:65]
        |       |               |   |   `--NUM_INT -> 3 [48:65]
        |       |               |   `--RBRACK -> ] [48:66]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [48:68]
        |       |               |   `--ANNOTATION -> ANNOTATION [48:68]
        |       |               |       |--AT -> @ [48:68]
        |       |               |       `--IDENT -> Nullable [48:69]
        |       |               `--ARRAY_DECLARATOR -> [ [48:78]
        |       |                   |--EXPR -> EXPR [48:79]
        |       |                   |   `--NUM_INT -> 2 [48:79]
        |       |                   `--RBRACK -> ] [48:80]
        |       |--SEMI -> ; [48:81]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [49:9]
        |       |   |--MODIFIERS -> MODIFIERS [49:9]
        |       |   |   `--ANNOTATION -> ANNOTATION [49:9]
        |       |   |       |--AT -> @ [49:9]
        |       |   |       `--IDENT -> Nullable [49:10]
        |       |   |--TYPE -> TYPE [49:19]
        |       |   |   `--IDENT -> Object [49:19]
        |       |   |--IDENT -> tmp5 [49:26]
        |       |   `--ASSIGN -> = [49:31]
        |       |       `--EXPR -> EXPR [49:33]
        |       |           `--LITERAL_NEW -> new [49:33]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [49:37]
        |       |               |   `--ANNOTATION -> ANNOTATION [49:37]
        |       |               |       |--AT -> @ [49:37]
        |       |               |       `--IDENT -> Nullable [49:38]
        |       |               |--LITERAL_INT -> int [49:47]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [49:51]
        |       |               |   `--ANNOTATION -> ANNOTATION [49:51]
        |       |               |       |--AT -> @ [49:51]
        |       |               |       `--IDENT -> Nullable [49:52]
        |       |               |--ARRAY_DECLARATOR -> [ [49:61]
        |       |               |   |--EXPR -> EXPR [49:62]
        |       |               |   |   `--NUM_INT -> 3 [49:62]
        |       |               |   `--RBRACK -> ] [49:63]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [49:65]
        |       |               |   `--ANNOTATION -> ANNOTATION [49:65]
        |       |               |       |--AT -> @ [49:65]
        |       |               |       `--IDENT -> Nullable [49:66]
        |       |               `--ARRAY_DECLARATOR -> [ [49:75]
        |       |                   |--EXPR -> EXPR [49:76]
        |       |                   |   `--NUM_INT -> 2 [49:76]
        |       |                   `--RBRACK -> ] [49:77]
        |       |--SEMI -> ; [49:78]
        |       |--LITERAL_RETURN -> return [51:9]
        |       |   |--EXPR -> EXPR [51:16]
        |       |   |   `--IDENT -> array [51:16]
        |       |   `--SEMI -> ; [51:21]
        |       `--RCURLY -> } [52:5]
        `--RCURLY -> } [53:1]
