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]
|--IMPORT -> import [3:1]
|   |--DOT -> . [3:28]
|   |   |--DOT -> . [3:17]
|   |   |   |--DOT -> . [3:12]
|   |   |   |   |--IDENT -> java [3:8]
|   |   |   |   `--IDENT -> lang [3:13]
|   |   |   `--IDENT -> annotation [3:18]
|   |   `--IDENT -> ElementType [3:29]
|   `--SEMI -> ; [3:40]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:28]
|   |   |--DOT -> . [4:17]
|   |   |   |--DOT -> . [4:12]
|   |   |   |   |--IDENT -> java [4:8]
|   |   |   |   `--IDENT -> lang [4:13]
|   |   |   `--IDENT -> annotation [4:18]
|   |   `--IDENT -> Target [4:29]
|   `--SEMI -> ; [4:35]
|--CLASS_DEF -> CLASS_DEF [6:1]
|   |--MODIFIERS -> MODIFIERS [6:1]
|   |   `--LITERAL_PUBLIC -> public [6:1]
|   |--LITERAL_CLASS -> class [6:8]
|   |--IDENT -> InputAntlr4AstRegressionNestedTypeParametersAndArrayDeclarators [6:14]
|   `--OBJBLOCK -> OBJBLOCK [6:78]
|       |--LCURLY -> { [6:78]
|       |--CLASS_DEF -> CLASS_DEF [7:5]
|       |   |--MODIFIERS -> MODIFIERS [7:5]
|       |   |--LITERAL_CLASS -> class [7:5]
|       |   |--IDENT -> Outer [7:11]
|       |   `--OBJBLOCK -> OBJBLOCK [7:17]
|       |       |--LCURLY -> { [7:17]
|       |       |--CLASS_DEF -> CLASS_DEF [8:9]
|       |       |   |--MODIFIERS -> MODIFIERS [8:9]
|       |       |   |--LITERAL_CLASS -> class [8:9]
|       |       |   |--IDENT -> Inner [8:15]
|       |       |   `--OBJBLOCK -> OBJBLOCK [8:21]
|       |       |       |--LCURLY -> { [8:21]
|       |       |       |--CLASS_DEF -> CLASS_DEF [9:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [9:13]
|       |       |       |   |--LITERAL_CLASS -> class [9:13]
|       |       |       |   |--IDENT -> Inner2 [9:19]
|       |       |       |   `--OBJBLOCK -> OBJBLOCK [9:26]
|       |       |       |       |--LCURLY -> { [9:26]
|       |       |       |       `--RCURLY -> } [10:13]
|       |       |       `--RCURLY -> } [11:9]
|       |       |--CLASS_DEF -> CLASS_DEF [13:9]
|       |       |   |--MODIFIERS -> MODIFIERS [13:9]
|       |       |   |--LITERAL_CLASS -> class [13:9]
|       |       |   |--IDENT -> GInner [13:15]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [13:21]
|       |       |   |   |--GENERIC_START -> < [13:21]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [13:22]
|       |       |   |   |   `--IDENT -> X [13:22]
|       |       |   |   `--GENERIC_END -> > [13:23]
|       |       |   `--OBJBLOCK -> OBJBLOCK [13:25]
|       |       |       |--LCURLY -> { [13:25]
|       |       |       |--CLASS_DEF -> CLASS_DEF [14:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [14:13]
|       |       |       |   |--LITERAL_CLASS -> class [14:13]
|       |       |       |   |--IDENT -> GInner2 [14:19]
|       |       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [14:26]
|       |       |       |   |   |--GENERIC_START -> < [14:26]
|       |       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [14:27]
|       |       |       |   |   |   `--IDENT -> Y [14:27]
|       |       |       |   |   |--COMMA -> , [14:28]
|       |       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [14:30]
|       |       |       |   |   |   `--IDENT -> Z [14:30]
|       |       |       |   |   `--GENERIC_END -> > [14:31]
|       |       |       |   `--OBJBLOCK -> OBJBLOCK [14:33]
|       |       |       |       |--LCURLY -> { [14:33]
|       |       |       |       `--RCURLY -> } [14:34]
|       |       |       `--RCURLY -> } [15:9]
|       |       |--CLASS_DEF -> CLASS_DEF [17:9]
|       |       |   |--MODIFIERS -> MODIFIERS [17:9]
|       |       |   |--LITERAL_CLASS -> class [17:9]
|       |       |   |--IDENT -> Static [17:15]
|       |       |   `--OBJBLOCK -> OBJBLOCK [17:22]
|       |       |       |--LCURLY -> { [17:22]
|       |       |       `--RCURLY -> } [17:23]
|       |       |--CLASS_DEF -> CLASS_DEF [18:9]
|       |       |   |--MODIFIERS -> MODIFIERS [18:9]
|       |       |   |--LITERAL_CLASS -> class [18:9]
|       |       |   |--IDENT -> GStatic [18:15]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:22]
|       |       |   |   |--GENERIC_START -> < [18:22]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:23]
|       |       |   |   |   `--IDENT -> X [18:23]
|       |       |   |   |--COMMA -> , [18:24]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:26]
|       |       |   |   |   `--IDENT -> Y [18:26]
|       |       |   |   `--GENERIC_END -> > [18:27]
|       |       |   `--OBJBLOCK -> OBJBLOCK [18:29]
|       |       |       |--LCURLY -> { [18:29]
|       |       |       |--CLASS_DEF -> CLASS_DEF [19:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [19:13]
|       |       |       |   |--LITERAL_CLASS -> class [19:13]
|       |       |       |   |--IDENT -> GStatic2 [19:19]
|       |       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [19:27]
|       |       |       |   |   |--GENERIC_START -> < [19:27]
|       |       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [19:28]
|       |       |       |   |   |   `--IDENT -> Z [19:28]
|       |       |       |   |   `--GENERIC_END -> > [19:29]
|       |       |       |   `--OBJBLOCK -> OBJBLOCK [19:31]
|       |       |       |       |--LCURLY -> { [19:31]
|       |       |       |       `--RCURLY -> } [19:32]
|       |       |       `--RCURLY -> } [20:9]
|       |       `--RCURLY -> } [21:5]
|       |--CLASS_DEF -> CLASS_DEF [23:5]
|       |   |--MODIFIERS -> MODIFIERS [23:5]
|       |   |--LITERAL_CLASS -> class [23:5]
|       |   |--IDENT -> Test1 [23:11]
|       |   `--OBJBLOCK -> OBJBLOCK [23:17]
|       |       |--LCURLY -> { [23:17]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [24:9]
|       |       |   |--MODIFIERS -> MODIFIERS [24:9]
|       |       |   |   `--ANNOTATION -> ANNOTATION [24:9]
|       |       |   |       |--AT -> @ [24:9]
|       |       |   |       `--IDENT -> A1 [24:10]
|       |       |   |--TYPE -> TYPE [25:17]
|       |       |   |   |--DOT -> . [25:17]
|       |       |   |   |   |--DOT -> . [24:19]
|       |       |   |   |   |   |--IDENT -> Outer [24:13]
|       |       |   |   |   |   |--ANNOTATIONS -> ANNOTATIONS [24:21]
|       |       |   |   |   |   |   `--ANNOTATION -> ANNOTATION [24:21]
|       |       |   |   |   |   |       |--AT -> @ [24:21]
|       |       |   |   |   |   |       `--IDENT -> B1 [24:22]
|       |       |   |   |   |   |--IDENT -> GInner [24:25]
|       |       |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:31]
|       |       |   |   |   |       |--GENERIC_START -> < [24:31]
|       |       |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:32]
|       |       |   |   |   |       |   |--ANNOTATIONS -> ANNOTATIONS [24:32]
|       |       |   |   |   |       |   |   `--ANNOTATION -> ANNOTATION [24:32]
|       |       |   |   |   |       |   |       |--AT -> @ [24:32]
|       |       |   |   |   |       |   |       `--IDENT -> C1 [24:33]
|       |       |   |   |   |       |   |--IDENT -> MyList [24:36]
|       |       |   |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:42]
|       |       |   |   |   |       |       |--GENERIC_START -> < [24:42]
|       |       |   |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:43]
|       |       |   |   |   |       |       |   |--ANNOTATIONS -> ANNOTATIONS [24:43]
|       |       |   |   |   |       |       |   |   `--ANNOTATION -> ANNOTATION [24:43]
|       |       |   |   |   |       |       |   |       |--AT -> @ [24:43]
|       |       |   |   |   |       |       |   |       `--IDENT -> D1 [24:44]
|       |       |   |   |   |       |       |   |--IDENT -> Object [24:47]
|       |       |   |   |   |       |       |   |--ANNOTATIONS -> ANNOTATIONS [24:54]
|       |       |   |   |   |       |       |   |   `--ANNOTATION -> ANNOTATION [24:54]
|       |       |   |   |   |       |       |   |       |--AT -> @ [24:54]
|       |       |   |   |   |       |       |   |       `--IDENT -> E1 [24:55]
|       |       |   |   |   |       |       |   |--ARRAY_DECLARATOR -> [ [24:57]
|       |       |   |   |   |       |       |   |   `--RBRACK -> ] [24:58]
|       |       |   |   |   |       |       |   |--ANNOTATIONS -> ANNOTATIONS [24:60]
|       |       |   |   |   |       |       |   |   `--ANNOTATION -> ANNOTATION [24:60]
|       |       |   |   |   |       |       |   |       |--AT -> @ [24:60]
|       |       |   |   |   |       |       |   |       `--IDENT -> F1 [24:61]
|       |       |   |   |   |       |       |   `--ARRAY_DECLARATOR -> [ [24:63]
|       |       |   |   |   |       |       |       `--RBRACK -> ] [24:64]
|       |       |   |   |   |       |       `--GENERIC_END -> > [24:65]
|       |       |   |   |   |       `--GENERIC_END -> > [24:66]
|       |       |   |   |   |--ANNOTATIONS -> ANNOTATIONS [25:18]
|       |       |   |   |   |   `--ANNOTATION -> ANNOTATION [25:18]
|       |       |   |   |   |       |--AT -> @ [25:18]
|       |       |   |   |   |       `--IDENT -> G1 [25:19]
|       |       |   |   |   |--IDENT -> GInner2 [25:22]
|       |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [25:29]
|       |       |   |   |       |--GENERIC_START -> < [25:29]
|       |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [25:30]
|       |       |   |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:30]
|       |       |   |   |       |   |   `--ANNOTATION -> ANNOTATION [25:30]
|       |       |   |   |       |   |       |--AT -> @ [25:30]
|       |       |   |   |       |   |       `--IDENT -> H1 [25:31]
|       |       |   |   |       |   `--IDENT -> Integer [25:34]
|       |       |   |   |       |--COMMA -> , [25:41]
|       |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [25:43]
|       |       |   |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:43]
|       |       |   |   |       |   |   `--ANNOTATION -> ANNOTATION [25:43]
|       |       |   |   |       |   |       |--AT -> @ [25:43]
|       |       |   |   |       |   |       `--IDENT -> I [25:44]
|       |       |   |   |       |   `--IDENT -> Object [25:46]
|       |       |   |   |       `--GENERIC_END -> > [25:52]
|       |       |   |   |--ANNOTATIONS -> ANNOTATIONS [25:54]
|       |       |   |   |   `--ANNOTATION -> ANNOTATION [25:54]
|       |       |   |   |       |--AT -> @ [25:54]
|       |       |   |   |       `--IDENT -> J [25:55]
|       |       |   |   |--ARRAY_DECLARATOR -> [ [25:56]
|       |       |   |   |   `--RBRACK -> ] [25:57]
|       |       |   |   |--ANNOTATIONS -> ANNOTATIONS [25:59]
|       |       |   |   |   `--ANNOTATION -> ANNOTATION [25:59]
|       |       |   |   |       |--AT -> @ [25:59]
|       |       |   |   |       `--IDENT -> K [25:60]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [25:61]
|       |       |   |       `--RBRACK -> ] [25:62]
|       |       |   |--IDENT -> f4arrtop [25:64]
|       |       |   `--SEMI -> ; [25:72]
|       |       `--RCURLY -> } [26:5]
|       `--RCURLY -> } [27:1]
|--CLASS_DEF -> CLASS_DEF [29:1]
|   |--MODIFIERS -> MODIFIERS [29:1]
|   |--LITERAL_CLASS -> class [29:1]
|   |--IDENT -> MyList [29:7]
|   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [29:13]
|   |   |--GENERIC_START -> < [29:13]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [29:14]
|   |   |   `--IDENT -> K [29:14]
|   |   `--GENERIC_END -> > [29:15]
|   `--OBJBLOCK -> OBJBLOCK [29:17]
|       |--LCURLY -> { [29:17]
|       `--RCURLY -> } [29:19]
|--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 -> A1 [32:12]
|   `--OBJBLOCK -> OBJBLOCK [32:15]
|       |--LCURLY -> { [32:15]
|       `--RCURLY -> } [32:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [33:1]
|   |--MODIFIERS -> MODIFIERS [33:1]
|   |   `--ANNOTATION -> ANNOTATION [33:1]
|   |       |--AT -> @ [33:1]
|   |       |--IDENT -> Target [33:2]
|   |       |--LPAREN -> ( [33:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [33:9]
|   |       |   |--EXPR -> EXPR [33:21]
|   |       |   |   `--DOT -> . [33:21]
|   |       |   |       |--IDENT -> ElementType [33:10]
|   |       |   |       `--IDENT -> TYPE_USE [33:22]
|   |       |   |--COMMA -> , [33:30]
|   |       |   |--EXPR -> EXPR [33:43]
|   |       |   |   `--DOT -> . [33:43]
|   |       |   |       |--IDENT -> ElementType [33:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [33:44]
|   |       |   `--RCURLY -> } [33:58]
|   |       `--RPAREN -> ) [33:59]
|   |--AT -> @ [34:1]
|   |--LITERAL_INTERFACE -> interface [34:2]
|   |--IDENT -> B1 [34:12]
|   `--OBJBLOCK -> OBJBLOCK [34:15]
|       |--LCURLY -> { [34:15]
|       `--RCURLY -> } [34:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [35:1]
|   |--MODIFIERS -> MODIFIERS [35:1]
|   |   `--ANNOTATION -> ANNOTATION [35:1]
|   |       |--AT -> @ [35:1]
|   |       |--IDENT -> Target [35:2]
|   |       |--LPAREN -> ( [35:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [35:9]
|   |       |   |--EXPR -> EXPR [35:21]
|   |       |   |   `--DOT -> . [35:21]
|   |       |   |       |--IDENT -> ElementType [35:10]
|   |       |   |       `--IDENT -> TYPE_USE [35:22]
|   |       |   |--COMMA -> , [35:30]
|   |       |   |--EXPR -> EXPR [35:43]
|   |       |   |   `--DOT -> . [35:43]
|   |       |   |       |--IDENT -> ElementType [35:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [35:44]
|   |       |   `--RCURLY -> } [35:58]
|   |       `--RPAREN -> ) [35:59]
|   |--AT -> @ [36:1]
|   |--LITERAL_INTERFACE -> interface [36:2]
|   |--IDENT -> C1 [36:12]
|   `--OBJBLOCK -> OBJBLOCK [36:15]
|       |--LCURLY -> { [36:15]
|       `--RCURLY -> } [36:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [37:1]
|   |--MODIFIERS -> MODIFIERS [37:1]
|   |   `--ANNOTATION -> ANNOTATION [37:1]
|   |       |--AT -> @ [37:1]
|   |       |--IDENT -> Target [37:2]
|   |       |--LPAREN -> ( [37:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [37:9]
|   |       |   |--EXPR -> EXPR [37:21]
|   |       |   |   `--DOT -> . [37:21]
|   |       |   |       |--IDENT -> ElementType [37:10]
|   |       |   |       `--IDENT -> TYPE_USE [37:22]
|   |       |   |--COMMA -> , [37:30]
|   |       |   |--EXPR -> EXPR [37:43]
|   |       |   |   `--DOT -> . [37:43]
|   |       |   |       |--IDENT -> ElementType [37:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [37:44]
|   |       |   `--RCURLY -> } [37:58]
|   |       `--RPAREN -> ) [37:59]
|   |--AT -> @ [38:1]
|   |--LITERAL_INTERFACE -> interface [38:2]
|   |--IDENT -> D1 [38:12]
|   `--OBJBLOCK -> OBJBLOCK [38:15]
|       |--LCURLY -> { [38:15]
|       `--RCURLY -> } [38:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [39:1]
|   |--MODIFIERS -> MODIFIERS [39:1]
|   |   `--ANNOTATION -> ANNOTATION [39:1]
|   |       |--AT -> @ [39:1]
|   |       |--IDENT -> Target [39:2]
|   |       |--LPAREN -> ( [39:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [39:9]
|   |       |   |--EXPR -> EXPR [39:21]
|   |       |   |   `--DOT -> . [39:21]
|   |       |   |       |--IDENT -> ElementType [39:10]
|   |       |   |       `--IDENT -> TYPE_USE [39:22]
|   |       |   |--COMMA -> , [39:30]
|   |       |   |--EXPR -> EXPR [39:43]
|   |       |   |   `--DOT -> . [39:43]
|   |       |   |       |--IDENT -> ElementType [39:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [39:44]
|   |       |   `--RCURLY -> } [39:58]
|   |       `--RPAREN -> ) [39:59]
|   |--AT -> @ [40:1]
|   |--LITERAL_INTERFACE -> interface [40:2]
|   |--IDENT -> E1 [40:12]
|   `--OBJBLOCK -> OBJBLOCK [40:15]
|       |--LCURLY -> { [40:15]
|       `--RCURLY -> } [40:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [41:1]
|   |--MODIFIERS -> MODIFIERS [41:1]
|   |   `--ANNOTATION -> ANNOTATION [41:1]
|   |       |--AT -> @ [41:1]
|   |       |--IDENT -> Target [41:2]
|   |       |--LPAREN -> ( [41:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [41:9]
|   |       |   |--EXPR -> EXPR [41:21]
|   |       |   |   `--DOT -> . [41:21]
|   |       |   |       |--IDENT -> ElementType [41:10]
|   |       |   |       `--IDENT -> TYPE_USE [41:22]
|   |       |   |--COMMA -> , [41:30]
|   |       |   |--EXPR -> EXPR [41:43]
|   |       |   |   `--DOT -> . [41:43]
|   |       |   |       |--IDENT -> ElementType [41:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [41:44]
|   |       |   `--RCURLY -> } [41:58]
|   |       `--RPAREN -> ) [41:59]
|   |--AT -> @ [42:1]
|   |--LITERAL_INTERFACE -> interface [42:2]
|   |--IDENT -> F1 [42:12]
|   `--OBJBLOCK -> OBJBLOCK [42:15]
|       |--LCURLY -> { [42:15]
|       `--RCURLY -> } [42:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [43:1]
|   |--MODIFIERS -> MODIFIERS [43:1]
|   |   `--ANNOTATION -> ANNOTATION [43:1]
|   |       |--AT -> @ [43:1]
|   |       |--IDENT -> Target [43:2]
|   |       |--LPAREN -> ( [43:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [43:9]
|   |       |   |--EXPR -> EXPR [43:21]
|   |       |   |   `--DOT -> . [43:21]
|   |       |   |       |--IDENT -> ElementType [43:10]
|   |       |   |       `--IDENT -> TYPE_USE [43:22]
|   |       |   |--COMMA -> , [43:30]
|   |       |   |--EXPR -> EXPR [43:43]
|   |       |   |   `--DOT -> . [43:43]
|   |       |   |       |--IDENT -> ElementType [43:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [43:44]
|   |       |   `--RCURLY -> } [43:58]
|   |       `--RPAREN -> ) [43:59]
|   |--AT -> @ [44:1]
|   |--LITERAL_INTERFACE -> interface [44:2]
|   |--IDENT -> G1 [44:12]
|   `--OBJBLOCK -> OBJBLOCK [44:15]
|       |--LCURLY -> { [44:15]
|       `--RCURLY -> } [44:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [45:1]
|   |--MODIFIERS -> MODIFIERS [45:1]
|   |   `--ANNOTATION -> ANNOTATION [45:1]
|   |       |--AT -> @ [45:1]
|   |       |--IDENT -> Target [45:2]
|   |       |--LPAREN -> ( [45:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [45:9]
|   |       |   |--EXPR -> EXPR [45:21]
|   |       |   |   `--DOT -> . [45:21]
|   |       |   |       |--IDENT -> ElementType [45:10]
|   |       |   |       `--IDENT -> TYPE_USE [45:22]
|   |       |   |--COMMA -> , [45:30]
|   |       |   |--EXPR -> EXPR [45:43]
|   |       |   |   `--DOT -> . [45:43]
|   |       |   |       |--IDENT -> ElementType [45:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [45:44]
|   |       |   `--RCURLY -> } [45:58]
|   |       `--RPAREN -> ) [45:59]
|   |--AT -> @ [46:1]
|   |--LITERAL_INTERFACE -> interface [46:2]
|   |--IDENT -> H1 [46:12]
|   `--OBJBLOCK -> OBJBLOCK [46:15]
|       |--LCURLY -> { [46:15]
|       `--RCURLY -> } [46:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [47:1]
|   |--MODIFIERS -> MODIFIERS [47:1]
|   |   `--ANNOTATION -> ANNOTATION [47:1]
|   |       |--AT -> @ [47:1]
|   |       |--IDENT -> Target [47:2]
|   |       |--LPAREN -> ( [47:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [47:9]
|   |       |   |--EXPR -> EXPR [47:21]
|   |       |   |   `--DOT -> . [47:21]
|   |       |   |       |--IDENT -> ElementType [47:10]
|   |       |   |       `--IDENT -> TYPE_USE [47:22]
|   |       |   |--COMMA -> , [47:30]
|   |       |   |--EXPR -> EXPR [47:43]
|   |       |   |   `--DOT -> . [47:43]
|   |       |   |       |--IDENT -> ElementType [47:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [47:44]
|   |       |   `--RCURLY -> } [47:58]
|   |       `--RPAREN -> ) [47:59]
|   |--AT -> @ [48:1]
|   |--LITERAL_INTERFACE -> interface [48:2]
|   |--IDENT -> I1 [48:12]
|   `--OBJBLOCK -> OBJBLOCK [48:15]
|       |--LCURLY -> { [48:15]
|       `--RCURLY -> } [48:17]
|--ANNOTATION_DEF -> ANNOTATION_DEF [49:1]
|   |--MODIFIERS -> MODIFIERS [49:1]
|   |   `--ANNOTATION -> ANNOTATION [49:1]
|   |       |--AT -> @ [49:1]
|   |       |--IDENT -> Target [49:2]
|   |       |--LPAREN -> ( [49:8]
|   |       |--ANNOTATION_ARRAY_INIT -> { [49:9]
|   |       |   |--EXPR -> EXPR [49:21]
|   |       |   |   `--DOT -> . [49:21]
|   |       |   |       |--IDENT -> ElementType [49:10]
|   |       |   |       `--IDENT -> TYPE_USE [49:22]
|   |       |   |--COMMA -> , [49:30]
|   |       |   |--EXPR -> EXPR [49:43]
|   |       |   |   `--DOT -> . [49:43]
|   |       |   |       |--IDENT -> ElementType [49:32]
|   |       |   |       `--IDENT -> TYPE_PARAMETER [49:44]
|   |       |   `--RCURLY -> } [49:58]
|   |       `--RPAREN -> ) [49:59]
|   |--AT -> @ [50:1]
|   |--LITERAL_INTERFACE -> interface [50:2]
|   |--IDENT -> J1 [50:12]
|   `--OBJBLOCK -> OBJBLOCK [50:15]
|       |--LCURLY -> { [50:15]
|       `--RCURLY -> } [50:17]
`--ANNOTATION_DEF -> ANNOTATION_DEF [51:1]
    |--MODIFIERS -> MODIFIERS [51:1]
    |   `--ANNOTATION -> ANNOTATION [51:1]
    |       |--AT -> @ [51:1]
    |       |--IDENT -> Target [51:2]
    |       |--LPAREN -> ( [51:8]
    |       |--ANNOTATION_ARRAY_INIT -> { [51:9]
    |       |   |--EXPR -> EXPR [51:21]
    |       |   |   `--DOT -> . [51:21]
    |       |   |       |--IDENT -> ElementType [51:10]
    |       |   |       `--IDENT -> TYPE_USE [51:22]
    |       |   |--COMMA -> , [51:30]
    |       |   |--EXPR -> EXPR [51:43]
    |       |   |   `--DOT -> . [51:43]
    |       |   |       |--IDENT -> ElementType [51:32]
    |       |   |       `--IDENT -> TYPE_PARAMETER [51:44]
    |       |   `--RCURLY -> } [51:58]
    |       `--RPAREN -> ) [51:59]
    |--AT -> @ [52:1]
    |--LITERAL_INTERFACE -> interface [52:2]
    |--IDENT -> K1 [52:12]
    `--OBJBLOCK -> OBJBLOCK [52:15]
        |--LCURLY -> { [52:15]
        `--RCURLY -> } [52:17]
