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