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