COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
|   |--ANNOTATIONS -> ANNOTATIONS [2:40]
|   |--DOT -> . [2:40]
|   |   |--DOT -> . [2:29]
|   |   |   |--DOT -> . [2:23]
|   |   |   |   |--DOT -> . [2:12]
|   |   |   |   |   |--IDENT -> com [2:9]
|   |   |   |   |   `--IDENT -> puppycrawl [2:13]
|   |   |   |   `--IDENT -> tools [2:24]
|   |   |   `--IDENT -> checkstyle [2:30]
|   |   `--IDENT -> grammar [2:41]
|   `--SEMI -> ; [2:48]
|--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 -> ElementType [4:29]
|   `--SEMI -> ; [4:40]
|--IMPORT -> import [5:1]
|   |--DOT -> . [5:28]
|   |   |--DOT -> . [5:17]
|   |   |   |--DOT -> . [5:12]
|   |   |   |   |--IDENT -> java [5:8]
|   |   |   |   `--IDENT -> lang [5:13]
|   |   |   `--IDENT -> annotation [5:18]
|   |   `--IDENT -> Retention [5:29]
|   `--SEMI -> ; [5:38]
|--IMPORT -> import [6:1]
|   |--DOT -> . [6:28]
|   |   |--DOT -> . [6:17]
|   |   |   |--DOT -> . [6:12]
|   |   |   |   |--IDENT -> java [6:8]
|   |   |   |   `--IDENT -> lang [6:13]
|   |   |   `--IDENT -> annotation [6:18]
|   |   `--IDENT -> RetentionPolicy [6:29]
|   `--SEMI -> ; [6:44]
|--IMPORT -> import [7:1]
|   |--DOT -> . [7:28]
|   |   |--DOT -> . [7:17]
|   |   |   |--DOT -> . [7:12]
|   |   |   |   |--IDENT -> java [7:8]
|   |   |   |   `--IDENT -> lang [7:13]
|   |   |   `--IDENT -> annotation [7:18]
|   |   `--IDENT -> Target [7:29]
|   `--SEMI -> ; [7:35]
|--IMPORT -> import [8:1]
|   |--DOT -> . [8:17]
|   |   |--DOT -> . [8:12]
|   |   |   |--IDENT -> java [8:8]
|   |   |   `--IDENT -> util [8:13]
|   |   `--IDENT -> ArrayList [8:18]
|   `--SEMI -> ; [8:27]
|--IMPORT -> import [9:1]
|   |--DOT -> . [9:17]
|   |   |--DOT -> . [9:12]
|   |   |   |--IDENT -> java [9:8]
|   |   |   `--IDENT -> util [9:13]
|   |   `--IDENT -> Collections [9:18]
|   `--SEMI -> ; [9:29]
|--IMPORT -> import [10:1]
|   |--DOT -> . [10:17]
|   |   |--DOT -> . [10:12]
|   |   |   |--IDENT -> java [10:8]
|   |   |   `--IDENT -> util [10:13]
|   |   `--IDENT -> Comparator [10:18]
|   `--SEMI -> ; [10:28]
|--IMPORT -> import [11:1]
|   |--DOT -> . [11:17]
|   |   |--DOT -> . [11:12]
|   |   |   |--IDENT -> java [11:8]
|   |   |   `--IDENT -> util [11:13]
|   |   `--IDENT -> Map [11:18]
|   `--SEMI -> ; [11:21]
|--IMPORT -> import [12:1]
|   |--DOT -> . [12:17]
|   |   |--DOT -> . [12:12]
|   |   |   |--IDENT -> java [12:8]
|   |   |   `--IDENT -> util [12:13]
|   |   `--IDENT -> List [12:18]
|   `--SEMI -> ; [12:22]
|--IMPORT -> import [13:1]
|   |--DOT -> . [13:26]
|   |   |--DOT -> . [13:17]
|   |   |   |--DOT -> . [13:12]
|   |   |   |   |--IDENT -> java [13:8]
|   |   |   |   `--IDENT -> util [13:13]
|   |   |   `--IDENT -> function [13:18]
|   |   `--IDENT -> IntBinaryOperator [13:27]
|   `--SEMI -> ; [13:44]
|--IMPORT -> import [14:1]
|   |--DOT -> . [14:26]
|   |   |--DOT -> . [14:17]
|   |   |   |--DOT -> . [14:12]
|   |   |   |   |--IDENT -> java [14:8]
|   |   |   |   `--IDENT -> util [14:13]
|   |   |   `--IDENT -> function [14:18]
|   |   `--IDENT -> Predicate [14:27]
|   `--SEMI -> ; [14:36]
|--IMPORT -> import [15:1]
|   |--DOT -> . [15:26]
|   |   |--DOT -> . [15:17]
|   |   |   |--DOT -> . [15:12]
|   |   |   |   |--IDENT -> java [15:8]
|   |   |   |   `--IDENT -> util [15:13]
|   |   |   `--IDENT -> function [15:18]
|   |   `--IDENT -> Supplier [15:27]
|   `--SEMI -> ; [15:35]
|--CLASS_DEF -> CLASS_DEF [17:1]
|   |--MODIFIERS -> MODIFIERS [17:1]
|   |   `--LITERAL_PUBLIC -> public [17:1]
|   |--LITERAL_CLASS -> class [17:8]
|   |--IDENT -> InputRegressionJava8Class2 [17:14]
|   `--OBJBLOCK -> OBJBLOCK [17:41]
|       |--LCURLY -> { [17:41]
|       |--CLASS_DEF -> CLASS_DEF [18:5]
|       |   |--MODIFIERS -> MODIFIERS [18:5]
|       |   |   `--LITERAL_STATIC -> static [18:5]
|       |   |--LITERAL_CLASS -> class [18:12]
|       |   |--IDENT -> Inner1 [18:18]
|       |   `--OBJBLOCK -> OBJBLOCK [18:25]
|       |       |--LCURLY -> { [18:25]
|       |       |--CLASS_DEF -> CLASS_DEF [18:27]
|       |       |   |--MODIFIERS -> MODIFIERS [18:27]
|       |       |   |   `--LITERAL_STATIC -> static [18:27]
|       |       |   |--LITERAL_CLASS -> class [18:34]
|       |       |   |--IDENT -> Inner2 [18:40]
|       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:46]
|       |       |   |   |--GENERIC_START -> < [18:46]
|       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:47]
|       |       |   |   |   `--IDENT -> V [18:47]
|       |       |   |   `--GENERIC_END -> > [18:48]
|       |       |   `--OBJBLOCK -> OBJBLOCK [18:50]
|       |       |       |--LCURLY -> { [18:50]
|       |       |       |--METHOD_DEF -> METHOD_DEF [18:52]
|       |       |       |   |--MODIFIERS -> MODIFIERS [18:52]
|       |       |       |   |   `--LITERAL_PUBLIC -> public [18:52]
|       |       |       |   |--TYPE -> TYPE [18:59]
|       |       |       |   |   `--LITERAL_VOID -> void [18:59]
|       |       |       |   |--IDENT -> m [18:64]
|       |       |       |   |--LPAREN -> ( [18:65]
|       |       |       |   |--PARAMETERS -> PARAMETERS [18:66]
|       |       |       |   |--RPAREN -> ) [18:66]
|       |       |       |   `--SLIST -> { [18:68]
|       |       |       |       `--RCURLY -> } [18:69]
|       |       |       `--RCURLY -> } [18:71]
|       |       `--RCURLY -> } [18:73]
|       |--CLASS_DEF -> CLASS_DEF [19:5]
|       |   |--MODIFIERS -> MODIFIERS [19:5]
|       |   |   `--LITERAL_STATIC -> static [19:5]
|       |   |--LITERAL_CLASS -> class [19:12]
|       |   |--IDENT -> Inner3 [19:18]
|       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [19:24]
|       |   |   |--GENERIC_START -> < [19:24]
|       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [19:25]
|       |   |   |   `--IDENT -> T [19:25]
|       |   |   `--GENERIC_END -> > [19:26]
|       |   `--OBJBLOCK -> OBJBLOCK [19:28]
|       |       |--LCURLY -> { [19:28]
|       |       |--METHOD_DEF -> METHOD_DEF [19:30]
|       |       |   |--MODIFIERS -> MODIFIERS [19:30]
|       |       |   |   `--LITERAL_PUBLIC -> public [19:30]
|       |       |   |--TYPE -> TYPE [19:37]
|       |       |   |   `--LITERAL_VOID -> void [19:37]
|       |       |   |--IDENT -> m [19:42]
|       |       |   |--LPAREN -> ( [19:43]
|       |       |   |--PARAMETERS -> PARAMETERS [19:44]
|       |       |   |--RPAREN -> ) [19:44]
|       |       |   `--SLIST -> { [19:46]
|       |       |       `--RCURLY -> } [19:47]
|       |       `--RCURLY -> } [19:49]
|       |--METHOD_DEF -> METHOD_DEF [21:5]
|       |   |--MODIFIERS -> MODIFIERS [21:5]
|       |   |   `--LITERAL_PUBLIC -> public [21:5]
|       |   |--TYPE -> TYPE [21:12]
|       |   |   `--LITERAL_VOID -> void [21:12]
|       |   |--IDENT -> m1 [21:17]
|       |   |--LPAREN -> ( [21:19]
|       |   |--PARAMETERS -> PARAMETERS [21:20]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:20]
|       |   |       |--MODIFIERS -> MODIFIERS [21:20]
|       |   |       |   `--ANNOTATION -> ANNOTATION [21:20]
|       |   |       |       |--AT -> @ [21:20]
|       |   |       |       `--IDENT -> MyAnnotation [21:21]
|       |   |       |--TYPE -> TYPE [21:34]
|       |   |       |   |--IDENT -> String [21:34]
|       |   |       |   `--ANNOTATIONS -> ANNOTATIONS [21:41]
|       |   |       |       `--ANNOTATION -> ANNOTATION [21:41]
|       |   |       |           |--AT -> @ [21:41]
|       |   |       |           `--IDENT -> MyAnnotation [21:42]
|       |   |       |--ELLIPSIS -> ... [21:55]
|       |   |       `--IDENT -> vararg [21:59]
|       |   |--RPAREN -> ) [21:65]
|       |   `--SLIST -> { [21:67]
|       |       `--RCURLY -> } [21:68]
|       |--METHOD_DEF -> METHOD_DEF [22:5]
|       |   |--MODIFIERS -> MODIFIERS [22:5]
|       |   |   `--LITERAL_PUBLIC -> public [22:5]
|       |   |--TYPE -> TYPE [22:12]
|       |   |   |--IDENT -> String [22:12]
|       |   |   |--ANNOTATIONS -> ANNOTATIONS [22:24]
|       |   |   |   `--ANNOTATION -> ANNOTATION [22:24]
|       |   |   |       |--AT -> @ [22:24]
|       |   |   |       `--IDENT -> MyAnnotation [22:25]
|       |   |   |--ARRAY_DECLARATOR -> [ [22:38]
|       |   |   |   `--RBRACK -> ] [22:39]
|       |   |   |--ANNOTATIONS -> ANNOTATIONS [22:41]
|       |   |   |   `--ANNOTATION -> ANNOTATION [22:41]
|       |   |   |       |--AT -> @ [22:41]
|       |   |   |       `--IDENT -> MyAnnotation [22:42]
|       |   |   `--ARRAY_DECLARATOR -> [ [22:55]
|       |   |       `--RBRACK -> ] [22:56]
|       |   |--IDENT -> m2 [22:19]
|       |   |--LPAREN -> ( [22:21]
|       |   |--PARAMETERS -> PARAMETERS [22:22]
|       |   |--RPAREN -> ) [22:22]
|       |   `--SLIST -> { [22:58]
|       |       |--LITERAL_RETURN -> return [22:60]
|       |       |   |--EXPR -> EXPR [22:67]
|       |       |   |   `--LITERAL_NULL -> null [22:67]
|       |       |   `--SEMI -> ; [22:71]
|       |       `--RCURLY -> } [22:73]
|       |--METHOD_DEF -> METHOD_DEF [24:5]
|       |   |--MODIFIERS -> MODIFIERS [24:5]
|       |   |   `--LITERAL_PUBLIC -> public [24:5]
|       |   |--TYPE -> TYPE [24:12]
|       |   |   `--LITERAL_VOID -> void [24:12]
|       |   |--IDENT -> instructions [24:17]
|       |   |--LPAREN -> ( [24:29]
|       |   |--PARAMETERS -> PARAMETERS [24:30]
|       |   |--RPAREN -> ) [24:30]
|       |   `--SLIST -> { [24:32]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [26:12]
|       |       |   |--MODIFIERS -> MODIFIERS [26:12]
|       |       |   |--TYPE -> TYPE [26:12]
|       |       |   |   `--DOT -> . [26:12]
|       |       |   |       |--IDENT -> Map [26:9]
|       |       |   |       |--ANNOTATIONS -> ANNOTATIONS [26:13]
|       |       |   |       |   `--ANNOTATION -> ANNOTATION [26:13]
|       |       |   |       |       |--AT -> @ [26:13]
|       |       |   |       |       `--IDENT -> MyAnnotation [26:14]
|       |       |   |       `--IDENT -> Entry [26:27]
|       |       |   `--IDENT -> e [26:33]
|       |       |--SEMI -> ; [26:34]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [27:9]
|       |       |   |--MODIFIERS -> MODIFIERS [27:9]
|       |       |   |--TYPE -> TYPE [27:9]
|       |       |   |   `--IDENT -> String [27:9]
|       |       |   |--IDENT -> str [27:16]
|       |       |   `--ASSIGN -> = [27:20]
|       |       |       `--EXPR -> EXPR [27:22]
|       |       |           `--TYPECAST -> ( [27:22]
|       |       |               |--TYPE -> TYPE [27:23]
|       |       |               |   |--ANNOTATIONS -> ANNOTATIONS [27:23]
|       |       |               |   |   `--ANNOTATION -> ANNOTATION [27:23]
|       |       |               |   |       |--AT -> @ [27:23]
|       |       |               |   |       `--IDENT -> MyAnnotation [27:24]
|       |       |               |   `--IDENT -> String [27:37]
|       |       |               |--RPAREN -> ) [27:43]
|       |       |               `--STRING_LITERAL -> "" [27:45]
|       |       |--SEMI -> ; [27:47]
|       |       |--EXPR -> EXPR [28:47]
|       |       |   `--METHOD_CALL -> ( [28:47]
|       |       |       |--DOT -> . [28:23]
|       |       |       |   |--LPAREN -> ( [28:9]
|       |       |       |   |--LITERAL_NEW -> new [28:10]
|       |       |       |   |   |--IDENT -> Inner3 [28:14]
|       |       |       |   |   |--LPAREN -> ( [28:20]
|       |       |       |   |   |--ELIST -> ELIST [28:21]
|       |       |       |   |   `--RPAREN -> ) [28:21]
|       |       |       |   |--RPAREN -> ) [28:22]
|       |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [28:24]
|       |       |       |   |   |--GENERIC_START -> < [28:24]
|       |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [28:25]
|       |       |       |   |   |   |--ANNOTATIONS -> ANNOTATIONS [28:25]
|       |       |       |   |   |   |   `--ANNOTATION -> ANNOTATION [28:25]
|       |       |       |   |   |   |       |--AT -> @ [28:25]
|       |       |       |   |   |   |       `--IDENT -> MyAnnotation [28:26]
|       |       |       |   |   |   `--IDENT -> String [28:39]
|       |       |       |   |   `--GENERIC_END -> > [28:45]
|       |       |       |   `--IDENT -> m [28:46]
|       |       |       |--ELIST -> ELIST [28:48]
|       |       |       `--RPAREN -> ) [28:48]
|       |       |--SEMI -> ; [28:49]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [29:9]
|       |       |   |--MODIFIERS -> MODIFIERS [29:9]
|       |       |   |--TYPE -> TYPE [29:9]
|       |       |   |   `--IDENT -> Object [29:9]
|       |       |   |--IDENT -> arr [29:16]
|       |       |   `--ASSIGN -> = [29:20]
|       |       |       `--EXPR -> EXPR [29:22]
|       |       |           `--LITERAL_NEW -> new [29:22]
|       |       |               |--ANNOTATIONS -> ANNOTATIONS [29:26]
|       |       |               |   `--ANNOTATION -> ANNOTATION [29:26]
|       |       |               |       |--AT -> @ [29:26]
|       |       |               |       `--IDENT -> MyAnnotation [29:27]
|       |       |               |--IDENT -> String [29:40]
|       |       |               |--ANNOTATIONS -> ANNOTATIONS [29:47]
|       |       |               |   `--ANNOTATION -> ANNOTATION [29:47]
|       |       |               |       |--AT -> @ [29:47]
|       |       |               |       `--IDENT -> MyAnnotation [29:48]
|       |       |               `--ARRAY_DECLARATOR -> [ [29:61]
|       |       |                   |--EXPR -> EXPR [29:62]
|       |       |                   |   `--NUM_INT -> 3 [29:62]
|       |       |                   `--RBRACK -> ] [29:63]
|       |       |--SEMI -> ; [29:64]
|       |       |--LITERAL_FOR -> for [30:9]
|       |       |   |--LPAREN -> ( [30:13]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [30:14]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [30:14]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [30:14]
|       |       |   |   |   |--TYPE -> TYPE [30:14]
|       |       |   |   |   |   |--IDENT -> String [30:14]
|       |       |   |   |   |   |--ANNOTATIONS -> ANNOTATIONS [30:23]
|       |       |   |   |   |   |   `--ANNOTATION -> ANNOTATION [30:23]
|       |       |   |   |   |   |       |--AT -> @ [30:23]
|       |       |   |   |   |   |       `--IDENT -> MyAnnotation [30:24]
|       |       |   |   |   |   `--ARRAY_DECLARATOR -> [ [30:37]
|       |       |   |   |   |       `--RBRACK -> ] [30:38]
|       |       |   |   |   `--IDENT -> a [30:21]
|       |       |   |   |--COLON -> : [30:40]
|       |       |   |   `--EXPR -> EXPR [30:44]
|       |       |   |       `--METHOD_CALL -> ( [30:44]
|       |       |   |           |--IDENT -> m2 [30:42]
|       |       |   |           |--ELIST -> ELIST [30:45]
|       |       |   |           `--RPAREN -> ) [30:45]
|       |       |   |--RPAREN -> ) [30:46]
|       |       |   `--SLIST -> { [30:48]
|       |       |       `--RCURLY -> } [30:49]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [31:9]
|       |       |   |--MODIFIERS -> MODIFIERS [31:9]
|       |       |   |--TYPE -> TYPE [31:9]
|       |       |   |   `--IDENT -> Object [31:9]
|       |       |   |--IDENT -> arr2 [31:16]
|       |       |   `--ASSIGN -> = [31:21]
|       |       |       `--EXPR -> EXPR [31:23]
|       |       |           `--LITERAL_NEW -> new [31:23]
|       |       |               |--ANNOTATIONS -> ANNOTATIONS [31:27]
|       |       |               |   `--ANNOTATION -> ANNOTATION [31:27]
|       |       |               |       |--AT -> @ [31:27]
|       |       |               |       `--IDENT -> MyAnnotation [31:28]
|       |       |               |--LITERAL_INT -> int [31:41]
|       |       |               `--ARRAY_DECLARATOR -> [ [31:44]
|       |       |                   |--EXPR -> EXPR [31:45]
|       |       |                   |   `--NUM_INT -> 3 [31:45]
|       |       |                   `--RBRACK -> ] [31:46]
|       |       |--SEMI -> ; [31:47]
|       |       `--RCURLY -> } [32:5]
|       `--RCURLY -> } [33:1]
`--ANNOTATION_DEF -> ANNOTATION_DEF [35:1]
    |--MODIFIERS -> MODIFIERS [35:1]
    |   |--ANNOTATION -> ANNOTATION [35:1]
    |   |   |--AT -> @ [35:1]
    |   |   |--IDENT -> Retention [35:2]
    |   |   |--LPAREN -> ( [35:11]
    |   |   |--EXPR -> EXPR [35:27]
    |   |   |   `--DOT -> . [35:27]
    |   |   |       |--IDENT -> RetentionPolicy [35:12]
    |   |   |       `--IDENT -> CLASS [35:28]
    |   |   `--RPAREN -> ) [35:33]
    |   `--ANNOTATION -> ANNOTATION [36:1]
    |       |--AT -> @ [36:1]
    |       |--IDENT -> Target [36:2]
    |       |--LPAREN -> ( [36:8]
    |       |--ANNOTATION_ARRAY_INIT -> { [36:9]
    |       |   |--EXPR -> EXPR [36:22]
    |       |   |   `--DOT -> . [36:22]
    |       |   |       |--IDENT -> ElementType [36:11]
    |       |   |       `--IDENT -> TYPE_USE [36:23]
    |       |   `--RCURLY -> } [36:32]
    |       `--RPAREN -> ) [36:33]
    |--AT -> @ [37:1]
    |--LITERAL_INTERFACE -> interface [37:2]
    |--IDENT -> MyAnnotation [37:12]
    `--OBJBLOCK -> OBJBLOCK [37:25]
        |--LCURLY -> { [37:25]
        `--RCURLY -> } [38:1]
