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]
|--IMPORT -> import [5:0]
|   |--DOT -> . [5:16]
|   |   |--DOT -> . [5:11]
|   |   |   |--IDENT -> java [5:7]
|   |   |   `--IDENT -> util [5:12]
|   |   `--IDENT -> List [5:17]
|   `--SEMI -> ; [5:21]
|--IMPORT -> import [6:0]
|   |--DOT -> . [6:25]
|   |   |--DOT -> . [6:16]
|   |   |   |--DOT -> . [6:11]
|   |   |   |   |--IDENT -> java [6:7]
|   |   |   |   `--IDENT -> util [6:12]
|   |   |   `--IDENT -> function [6:17]
|   |   `--IDENT -> Supplier [6:26]
|   `--SEMI -> ; [6:34]
|--CLASS_DEF -> CLASS_DEF [8:0]
|   |--MODIFIERS -> MODIFIERS [8:0]
|   |   `--LITERAL_PUBLIC -> public [8:0]
|   |--LITERAL_CLASS -> class [8:7]
|   |--IDENT -> InputAntlr4AstRegressionMethodRefs [8:13]
|   `--OBJBLOCK -> OBJBLOCK [8:48]
|       |--LCURLY -> { [8:48]
|       |--INTERFACE_DEF -> INTERFACE_DEF [9:3]
|       |   |--MODIFIERS -> MODIFIERS [9:3]
|       |   |--LITERAL_INTERFACE -> interface [9:3]
|       |   |--IDENT -> LambdaInt [9:13]
|       |   `--OBJBLOCK -> OBJBLOCK [9:23]
|       |       |--LCURLY -> { [9:23]
|       |       |--METHOD_DEF -> METHOD_DEF [10:8]
|       |       |   |--MODIFIERS -> MODIFIERS [10:8]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [10:8]
|       |       |   |   |--GENERIC_START -> < [10:8]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [10:9]
|       |       |   |   |   `--IDENT -> S [10:9]
|       |       |   |   |--COMMA -> , [10:10]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [10:12]
|       |       |   |   |   `--IDENT -> T [10:12]
|       |       |   |   `--GENERIC_END -> > [10:13]
|       |       |   |--TYPE -> TYPE [10:15]
|       |       |   |   `--LITERAL_VOID -> void [10:15]
|       |       |   |--IDENT -> m [10:20]
|       |       |   |--LPAREN -> ( [10:21]
|       |       |   |--PARAMETERS -> PARAMETERS [10:22]
|       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [10:22]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [10:22]
|       |       |   |   |   |--TYPE -> TYPE [10:22]
|       |       |   |   |   |   `--IDENT -> S [10:22]
|       |       |   |   |   `--IDENT -> p1 [10:24]
|       |       |   |   |--COMMA -> , [10:26]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:28]
|       |       |   |       |--MODIFIERS -> MODIFIERS [10:28]
|       |       |   |       |--TYPE -> TYPE [10:28]
|       |       |   |       |   `--IDENT -> T [10:28]
|       |       |   |       `--IDENT -> p2 [10:30]
|       |       |   |--RPAREN -> ) [10:32]
|       |       |   `--SEMI -> ; [10:33]
|       |       `--RCURLY -> } [11:4]
|       |--INTERFACE_DEF -> INTERFACE_DEF [13:4]
|       |   |--MODIFIERS -> MODIFIERS [13:4]
|       |   |--LITERAL_INTERFACE -> interface [13:4]
|       |   |--IDENT -> MyFunctionalInterface [13:14]
|       |   `--OBJBLOCK -> OBJBLOCK [13:36]
|       |       |--LCURLY -> { [13:36]
|       |       |--METHOD_DEF -> METHOD_DEF [14:8]
|       |       |   |--MODIFIERS -> MODIFIERS [14:8]
|       |       |   |--TYPE -> TYPE [14:8]
|       |       |   |   `--LITERAL_VOID -> void [14:8]
|       |       |   |--IDENT -> invokeMethodReference [14:13]
|       |       |   |--LPAREN -> ( [14:34]
|       |       |   |--PARAMETERS -> PARAMETERS [14:35]
|       |       |   |--RPAREN -> ) [14:35]
|       |       |   `--SEMI -> ; [14:36]
|       |       `--RCURLY -> } [15:4]
|       |--CLASS_DEF -> CLASS_DEF [17:4]
|       |   |--MODIFIERS -> MODIFIERS [17:4]
|       |   |   `--LITERAL_STATIC -> static [17:4]
|       |   |--LITERAL_CLASS -> class [17:11]
|       |   |--IDENT -> LambdaImpl [17:17]
|       |   |--IMPLEMENTS_CLAUSE -> implements [17:28]
|       |   |   `--IDENT -> LambdaInt [17:39]
|       |   `--OBJBLOCK -> OBJBLOCK [17:49]
|       |       |--LCURLY -> { [17:49]
|       |       |--CTOR_DEF -> CTOR_DEF [18:8]
|       |       |   |--MODIFIERS -> MODIFIERS [18:8]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:8]
|       |       |   |   |--GENERIC_START -> < [18:8]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:9]
|       |       |   |   |   `--IDENT -> S [18:9]
|       |       |   |   |--COMMA -> , [18:10]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:12]
|       |       |   |   |   `--IDENT -> T [18:12]
|       |       |   |   `--GENERIC_END -> > [18:13]
|       |       |   |--IDENT -> LambdaImpl [18:15]
|       |       |   |--LPAREN -> ( [18:25]
|       |       |   |--PARAMETERS -> PARAMETERS [18:26]
|       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [18:26]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [18:26]
|       |       |   |   |   |--TYPE -> TYPE [18:26]
|       |       |   |   |   |   `--IDENT -> S [18:26]
|       |       |   |   |   `--IDENT -> p1 [18:28]
|       |       |   |   |--COMMA -> , [18:30]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [18:32]
|       |       |   |       |--MODIFIERS -> MODIFIERS [18:32]
|       |       |   |       |--TYPE -> TYPE [18:32]
|       |       |   |       |   `--IDENT -> T [18:32]
|       |       |   |       `--IDENT -> p2 [18:34]
|       |       |   |--RPAREN -> ) [18:36]
|       |       |   `--SLIST -> { [18:38]
|       |       |       `--RCURLY -> } [19:8]
|       |       |--METHOD_DEF -> METHOD_DEF [21:8]
|       |       |   |--MODIFIERS -> MODIFIERS [21:8]
|       |       |   |   `--LITERAL_PUBLIC -> public [21:8]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [21:15]
|       |       |   |   |--GENERIC_START -> < [21:15]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [21:16]
|       |       |   |   |   `--IDENT -> S [21:16]
|       |       |   |   |--COMMA -> , [21:17]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [21:19]
|       |       |   |   |   `--IDENT -> T [21:19]
|       |       |   |   `--GENERIC_END -> > [21:20]
|       |       |   |--TYPE -> TYPE [21:22]
|       |       |   |   `--LITERAL_VOID -> void [21:22]
|       |       |   |--IDENT -> m [21:27]
|       |       |   |--LPAREN -> ( [21:28]
|       |       |   |--PARAMETERS -> PARAMETERS [21:29]
|       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [21:29]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [21:29]
|       |       |   |   |   |--TYPE -> TYPE [21:29]
|       |       |   |   |   |   `--IDENT -> S [21:29]
|       |       |   |   |   `--IDENT -> p1 [21:31]
|       |       |   |   |--COMMA -> , [21:33]
|       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:35]
|       |       |   |       |--MODIFIERS -> MODIFIERS [21:35]
|       |       |   |       |--TYPE -> TYPE [21:35]
|       |       |   |       |   `--IDENT -> T [21:35]
|       |       |   |       `--IDENT -> p2 [21:37]
|       |       |   |--RPAREN -> ) [21:39]
|       |       |   `--SLIST -> { [21:41]
|       |       |       `--RCURLY -> } [22:8]
|       |       `--RCURLY -> } [23:4]
|       |--METHOD_DEF -> METHOD_DEF [25:4]
|       |   |--MODIFIERS -> MODIFIERS [25:4]
|       |   |   `--LITERAL_PUBLIC -> public [25:4]
|       |   |--TYPE -> TYPE [25:11]
|       |   |   `--LITERAL_VOID -> void [25:11]
|       |   |--IDENT -> m [25:16]
|       |   |--LPAREN -> ( [25:17]
|       |   |--PARAMETERS -> PARAMETERS [25:18]
|       |   |--RPAREN -> ) [25:18]
|       |   `--SLIST -> { [25:20]
|       |       `--RCURLY -> } [26:4]
|       |--METHOD_DEF -> METHOD_DEF [28:4]
|       |   |--MODIFIERS -> MODIFIERS [28:4]
|       |   |   `--LITERAL_PUBLIC -> public [28:4]
|       |   |--TYPE -> TYPE [28:11]
|       |   |   `--LITERAL_VOID -> void [28:11]
|       |   |--IDENT -> main [28:16]
|       |   |--LPAREN -> ( [28:20]
|       |   |--PARAMETERS -> PARAMETERS [28:21]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [28:21]
|       |   |       |--MODIFIERS -> MODIFIERS [28:21]
|       |   |       |--TYPE -> TYPE [28:21]
|       |   |       |   |--IDENT -> String [28:21]
|       |   |       |   `--ARRAY_DECLARATOR -> [ [28:27]
|       |   |       |       `--RBRACK -> ] [28:28]
|       |   |       `--IDENT -> args [28:30]
|       |   |--RPAREN -> ) [28:34]
|       |   `--SLIST -> { [28:36]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [29:8]
|       |       |   |--MODIFIERS -> MODIFIERS [29:8]
|       |       |   |--TYPE -> TYPE [29:8]
|       |       |   |   `--IDENT -> MyFunctionalInterface [29:8]
|       |       |   |--IDENT -> fi [29:30]
|       |       |   `--ASSIGN -> = [29:33]
|       |       |       `--EXPR -> EXPR [30:56]
|       |       |           `--METHOD_REF -> :: [30:56]
|       |       |               |--LITERAL_NEW -> new [30:16]
|       |       |               |   |--IDENT -> InputAntlr4AstRegressionMethodRefs [30:20]
|       |       |               |   |--LPAREN -> ( [30:54]
|       |       |               |   |--ELIST -> ELIST [30:55]
|       |       |               |   `--RPAREN -> ) [30:55]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:58]
|       |       |               |   |--GENERIC_START -> < [30:58]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:59]
|       |       |               |   |   `--IDENT -> Integer [30:59]
|       |       |               |   |--COMMA -> , [30:66]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:68]
|       |       |               |   |   `--IDENT -> String [30:68]
|       |       |               |   |--COMMA -> , [30:74]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:76]
|       |       |               |   |   `--IDENT -> Long [30:76]
|       |       |               |   `--GENERIC_END -> > [30:80]
|       |       |               `--IDENT -> m [30:82]
|       |       |--SEMI -> ; [30:83]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
|       |       |   |--MODIFIERS -> MODIFIERS [31:8]
|       |       |   |--TYPE -> TYPE [31:8]
|       |       |   |   `--IDENT -> LambdaInt [31:8]
|       |       |   |--IDENT -> li [31:18]
|       |       |   `--ASSIGN -> = [31:21]
|       |       |       `--EXPR -> EXPR [31:33]
|       |       |           `--METHOD_REF -> :: [31:33]
|       |       |               |--IDENT -> LambdaImpl [31:23]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:35]
|       |       |               |   |--GENERIC_START -> < [31:35]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:36]
|       |       |               |   |   |--ANNOTATIONS -> ANNOTATIONS [31:36]
|       |       |               |   |   |   `--ANNOTATION -> ANNOTATION [31:36]
|       |       |               |   |   |       |--AT -> @ [31:36]
|       |       |               |   |   |       `--IDENT -> TA [31:37]
|       |       |               |   |   `--IDENT -> Object [31:40]
|       |       |               |   |--COMMA -> , [31:46]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:48]
|       |       |               |   |   |--ANNOTATIONS -> ANNOTATIONS [31:48]
|       |       |               |   |   |   `--ANNOTATION -> ANNOTATION [31:48]
|       |       |               |   |   |       |--AT -> @ [31:48]
|       |       |               |   |   |       `--IDENT -> TB [31:49]
|       |       |               |   |   `--IDENT -> Object [31:52]
|       |       |               |   `--GENERIC_END -> > [31:58]
|       |       |               `--LITERAL_NEW -> new [31:60]
|       |       |--SEMI -> ; [31:63]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [32:8]
|       |       |   |--MODIFIERS -> MODIFIERS [32:8]
|       |       |   |--TYPE -> TYPE [32:8]
|       |       |   |   `--IDENT -> Supplier [32:8]
|       |       |   |--IDENT -> s [32:17]
|       |       |   `--ASSIGN -> = [32:19]
|       |       |       `--EXPR -> EXPR [32:25]
|       |       |           `--METHOD_REF -> :: [32:25]
|       |       |               |--IDENT -> Bar1 [32:21]
|       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:27]
|       |       |               |   |--GENERIC_START -> < [32:27]
|       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:28]
|       |       |               |   |   `--IDENT -> String [32:28]
|       |       |               |   `--GENERIC_END -> > [32:34]
|       |       |               `--IDENT -> m [32:36]
|       |       |--SEMI -> ; [32:37]
|       |       |--EXPR -> EXPR [33:11]
|       |       |   `--ASSIGN -> = [33:11]
|       |       |       |--IDENT -> li [33:8]
|       |       |       `--METHOD_REF -> :: [33:15]
|       |       |           |--IDENT -> li [33:13]
|       |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [33:17]
|       |       |           |   |--GENERIC_START -> < [33:17]
|       |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [33:18]
|       |       |           |   |   |--ANNOTATIONS -> ANNOTATIONS [33:18]
|       |       |           |   |   |   `--ANNOTATION -> ANNOTATION [33:18]
|       |       |           |   |   |       |--AT -> @ [33:18]
|       |       |           |   |   |       `--IDENT -> TA [33:19]
|       |       |           |   |   `--IDENT -> Object [33:22]
|       |       |           |   |--COMMA -> , [33:28]
|       |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [33:30]
|       |       |           |   |   |--ANNOTATIONS -> ANNOTATIONS [33:30]
|       |       |           |   |   |   `--ANNOTATION -> ANNOTATION [33:30]
|       |       |           |   |   |       |--AT -> @ [33:30]
|       |       |           |   |   |       `--IDENT -> TB [33:31]
|       |       |           |   |   `--IDENT -> Object [33:34]
|       |       |           |   `--GENERIC_END -> > [33:40]
|       |       |           `--IDENT -> m [33:42]
|       |       |--SEMI -> ; [33:43]
|       |       |--EXPR -> EXPR [34:10]
|       |       |   `--ASSIGN -> = [34:10]
|       |       |       |--IDENT -> s [34:8]
|       |       |       `--METHOD_REF -> :: [34:16]
|       |       |           |--IDENT -> Bar1 [34:12]
|       |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [34:18]
|       |       |           |   |--GENERIC_START -> < [34:18]
|       |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [34:19]
|       |       |           |   |   |--IDENT -> List [34:19]
|       |       |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [34:23]
|       |       |           |   |       |--GENERIC_START -> < [34:23]
|       |       |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [34:24]
|       |       |           |   |       |   `--IDENT -> String [34:24]
|       |       |           |   |       `--GENERIC_END -> > [34:30]
|       |       |           |   `--GENERIC_END -> > [34:31]
|       |       |           `--IDENT -> m [34:33]
|       |       |--SEMI -> ; [34:34]
|       |       |--EXPR -> EXPR [35:10]
|       |       |   `--ASSIGN -> = [35:10]
|       |       |       |--IDENT -> s [35:8]
|       |       |       `--METHOD_REF -> :: [35:16]
|       |       |           |--IDENT -> Bar1 [35:12]
|       |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:18]
|       |       |           |   |--GENERIC_START -> < [35:18]
|       |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:19]
|       |       |           |   |   |--IDENT -> List [35:19]
|       |       |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:23]
|       |       |           |   |       |--GENERIC_START -> < [35:23]
|       |       |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:24]
|       |       |           |   |       |   |--IDENT -> List [35:24]
|       |       |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:28]
|       |       |           |   |       |       |--GENERIC_START -> < [35:28]
|       |       |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:29]
|       |       |           |   |       |       |   `--WILDCARD_TYPE -> ? [35:29]
|       |       |           |   |       |       `--GENERIC_END -> > [35:30]
|       |       |           |   |       `--GENERIC_END -> > [35:31]
|       |       |           |   `--GENERIC_END -> > [35:32]
|       |       |           `--IDENT -> m [35:34]
|       |       |--SEMI -> ; [35:35]
|       |       `--RCURLY -> } [36:4]
|       `--RCURLY -> } [37:0]
|--CLASS_DEF -> CLASS_DEF [39:0]
|   |--MODIFIERS -> MODIFIERS [39:0]
|   |--LITERAL_CLASS -> class [39:0]
|   |--IDENT -> Bar1 [39:6]
|   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [39:10]
|   |   |--GENERIC_START -> < [39:10]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [39:11]
|   |   |   `--IDENT -> T [39:11]
|   |   `--GENERIC_END -> > [39:12]
|   `--OBJBLOCK -> OBJBLOCK [39:14]
|       |--LCURLY -> { [39:14]
|       |--METHOD_DEF -> METHOD_DEF [40:4]
|       |   |--MODIFIERS -> MODIFIERS [40:4]
|       |   |   `--LITERAL_STATIC -> static [40:4]
|       |   |--TYPE -> TYPE [40:11]
|       |   |   `--IDENT -> Object [40:11]
|       |   |--IDENT -> m [40:18]
|       |   |--LPAREN -> ( [40:19]
|       |   |--PARAMETERS -> PARAMETERS [40:20]
|       |   |--RPAREN -> ) [40:20]
|       |   `--SLIST -> { [40:22]
|       |       |--LITERAL_RETURN -> return [41:8]
|       |       |   |--EXPR -> EXPR [41:15]
|       |       |   |   `--LITERAL_NULL -> null [41:15]
|       |       |   `--SEMI -> ; [41:19]
|       |       `--RCURLY -> } [42:4]
|       `--RCURLY -> } [43:0]
|--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: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:59]
|   |       `--RPAREN -> ) [45:60]
|   |--AT -> @ [46:0]
|   |--LITERAL_INTERFACE -> interface [46:1]
|   |--IDENT -> TA [46:11]
|   `--OBJBLOCK -> OBJBLOCK [46:14]
|       |--LCURLY -> { [46:14]
|       `--RCURLY -> } [47:0]
`--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: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:59]
    |       `--RPAREN -> ) [49:60]
    |--AT -> @ [50:0]
    |--LITERAL_INTERFACE -> interface [50:1]
    |--IDENT -> TB [50:11]
    `--OBJBLOCK -> OBJBLOCK [50:14]
        |--LCURLY -> { [50:14]
        `--RCURLY -> } [51:0]
