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