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