path: root/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1Ast.txt

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 -> grammars [2:40]
`--SEMI -> ; [2:48]
SEMI -> ; [3:0]
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 -> InputRegressionJava8Class1 [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 -> m [21:16]
    |   |--LPAREN -> ( [21:17]
    |   |--PARAMETERS -> PARAMETERS [21:18]
    |   |--RPAREN -> ) [21:18]
    |   `--SLIST -> { [21:20]
    |       `--RCURLY -> } [21:21]
    |--METHOD_DEF -> METHOD_DEF [22:4]
    |   |--MODIFIERS -> MODIFIERS [22:4]
    |   |   |--LITERAL_PUBLIC -> public [22:4]
    |   |   `--LITERAL_STATIC -> static [22:11]
    |   |--TYPE -> TYPE [22:18]
    |   |   `--LITERAL_VOID -> void [22:18]
    |   |--IDENT -> sm [22:23]
    |   |--LPAREN -> ( [22:25]
    |   |--PARAMETERS -> PARAMETERS [22:26]
    |   |--RPAREN -> ) [22:26]
    |   `--SLIST -> { [22:28]
    |       `--RCURLY -> } [22:29]
    |--METHOD_DEF -> METHOD_DEF [23:4]
    |   |--MODIFIERS -> MODIFIERS [23:4]
    |   |--TYPE -> TYPE [23:4]
    |   |   `--LITERAL_VOID -> void [23:4]
    |   |--IDENT -> m1 [23:9]
    |   |--LPAREN -> ( [23:11]
    |   |--PARAMETERS -> PARAMETERS [23:12]
    |   |--RPAREN -> ) [23:12]
    |   |--LITERAL_THROWS -> throws [23:14]
    |   |   |--ANNOTATIONS -> ANNOTATIONS [23:21]
    |   |   |   `--ANNOTATION -> ANNOTATION [23:21]
    |   |   |       |--AT -> @ [23:21]
    |   |   |       `--IDENT -> Nullable [23:22]
    |   |   `--IDENT -> Exception [23:31]
    |   `--SLIST -> { [23:41]
    |       `--RCURLY -> } [23:42]
    |--METHOD_DEF -> METHOD_DEF [24:4]
    |   |--MODIFIERS -> MODIFIERS [24:4]
    |   |   |--LITERAL_PUBLIC -> public [24:4]
    |   |   `--LITERAL_STATIC -> static [24:11]
    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [24:18]
    |   |   |--GENERIC_START -> < [24:18]
    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [24:19]
    |   |   |   `--IDENT -> T [24:19]
    |   |   `--GENERIC_END -> > [24:20]
    |   |--TYPE -> TYPE [24:22]
    |   |   `--LITERAL_VOID -> void [24:22]
    |   |--IDENT -> m2 [24:27]
    |   |--LPAREN -> ( [24:29]
    |   |--PARAMETERS -> PARAMETERS [24:42]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [24:42]
    |   |       |--MODIFIERS -> MODIFIERS [24:42]
    |   |       |--TYPE -> TYPE [24:42]
    |   |       |   `--ARRAY_DECLARATOR -> [ [24:42]
    |   |       |       |--IDENT -> T [24:30]
    |   |       |       |--ANNOTATIONS -> ANNOTATIONS [24:32]
    |   |       |       |   `--ANNOTATION -> ANNOTATION [24:32]
    |   |       |       |       |--AT -> @ [24:32]
    |   |       |       |       `--IDENT -> Nullable [24:33]
    |   |       |       `--RBRACK -> ] [24:43]
    |   |       `--IDENT -> array [24:45]
    |   |--RPAREN -> ) [24:50]
    |   `--SLIST -> { [24:52]
    |       `--RCURLY -> } [24:53]
    |--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 -> m3 [25:16]
    |   |--LPAREN -> ( [25:18]
    |   |--PARAMETERS -> PARAMETERS [25:19]
    |   |--RPAREN -> ) [25:19]
    |   |--LITERAL_THROWS -> throws [25:21]
    |   |   |--IDENT -> NullPointerException [25:28]
    |   |   |--COMMA -> , [25:48]
    |   |   |--ANNOTATIONS -> ANNOTATIONS [25:50]
    |   |   |   `--ANNOTATION -> ANNOTATION [25:50]
    |   |   |       |--AT -> @ [25:50]
    |   |   |       `--IDENT -> Nullable [25:51]
    |   |   `--IDENT -> ArrayIndexOutOfBoundsException [25:60]
    |   `--SLIST -> { [25:91]
    |       `--RCURLY -> } [25:92]
    |--METHOD_DEF -> METHOD_DEF [26:4]
    |   |--MODIFIERS -> MODIFIERS [26:4]
    |   |   `--LITERAL_PUBLIC -> public [26:4]
    |   |--TYPE -> TYPE [26:11]
    |   |   `--LITERAL_VOID -> void [26:11]
    |   |--IDENT -> m4 [26:16]
    |   |--LPAREN -> ( [26:18]
    |   |--PARAMETERS -> PARAMETERS [26:19]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [26:19]
    |   |       |--MODIFIERS -> MODIFIERS [26:19]
    |   |       |--TYPE -> TYPE [26:19]
    |   |       |   `--IDENT -> InputRegressionJava8Class1 [26:19]
    |   |       `--LITERAL_THIS -> this [26:46]
    |   |--RPAREN -> ) [26:50]
    |   `--SLIST -> { [26:52]
    |       `--RCURLY -> } [26:53]
    |--METHOD_DEF -> METHOD_DEF [27:4]
    |   |--MODIFIERS -> MODIFIERS [27:4]
    |   |   `--LITERAL_PUBLIC -> public [27:4]
    |   |--TYPE -> TYPE [27:11]
    |   |   `--LITERAL_VOID -> void [27:11]
    |   |--IDENT -> m5 [27:16]
    |   |--LPAREN -> ( [27:18]
    |   |--PARAMETERS -> PARAMETERS [27:19]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [27:19]
    |   |       |--MODIFIERS -> MODIFIERS [27:19]
    |   |       |   `--ANNOTATION -> ANNOTATION [27:19]
    |   |       |       |--AT -> @ [27:19]
    |   |       |       `--IDENT -> Nullable [27:20]
    |   |       |--TYPE -> TYPE [27:29]
    |   |       |   `--IDENT -> InputRegressionJava8Class1 [27:29]
    |   |       `--LITERAL_THIS -> this [27:56]
    |   |--RPAREN -> ) [27:60]
    |   `--SLIST -> { [27:62]
    |       `--RCURLY -> } [27:63]
    |--INSTANCE_INIT -> INSTANCE_INIT [29:4]
    |   `--SLIST -> { [29:4]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [30:8]
    |       |   |--MODIFIERS -> MODIFIERS [30:8]
    |       |   |--TYPE -> TYPE [30:8]
    |       |   |   |--IDENT -> List [30:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:12]
    |       |   |       |--GENERIC_START -> < [30:12]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:13]
    |       |   |       |   `--IDENT -> String [30:13]
    |       |   |       `--GENERIC_END -> > [30:19]
    |       |   |--IDENT -> vlist [30:21]
    |       |   `--ASSIGN -> = [30:27]
    |       |       `--EXPR -> EXPR [30:29]
    |       |           `--LITERAL_NEW -> new [30:29]
    |       |               |--IDENT -> ArrayList [30:33]
    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:42]
    |       |               |   |--GENERIC_START -> < [30:42]
    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:43]
    |       |               |   |   `--IDENT -> String [30:43]
    |       |               |   `--GENERIC_END -> > [30:49]
    |       |               |--LPAREN -> ( [30:50]
    |       |               |--ELIST -> ELIST [30:51]
    |       |               `--RPAREN -> ) [30:51]
    |       |--SEMI -> ; [30:52]
    |       `--RCURLY -> } [31:4]
    |--METHOD_DEF -> METHOD_DEF [33:4]
    |   |--MODIFIERS -> MODIFIERS [33:4]
    |   |   `--LITERAL_PUBLIC -> public [33:4]
    |   |--TYPE -> TYPE [33:11]
    |   |   `--LITERAL_VOID -> void [33:11]
    |   |--IDENT -> instructions [33:16]
    |   |--LPAREN -> ( [33:28]
    |   |--PARAMETERS -> PARAMETERS [33:29]
    |   |--RPAREN -> ) [33:29]
    |   `--SLIST -> { [33:31]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [35:8]
    |       |   |--MODIFIERS -> MODIFIERS [35:8]
    |       |   |--TYPE -> TYPE [35:8]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [35:8]
    |       |   |--IDENT -> b [35:16]
    |       |   `--ASSIGN -> = [35:18]
    |       |       `--EXPR -> EXPR [35:34]
    |       |           `--GT -> > [35:34]
    |       |               |--METHOD_CALL -> ( [35:31]
    |       |               |   |--DOT -> . [35:24]
    |       |               |   |   |--IDENT -> Math [35:20]
    |       |               |   |   `--IDENT -> random [35:25]
    |       |               |   |--ELIST -> ELIST [35:32]
    |       |               |   `--RPAREN -> ) [35:32]
    |       |               `--NUM_INT -> 0 [35:36]
    |       |--SEMI -> ; [35:37]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [37:8]
    |       |   |--MODIFIERS -> MODIFIERS [37:8]
    |       |   |--TYPE -> TYPE [37:8]
    |       |   |   `--LITERAL_INT -> int [37:8]
    |       |   `--IDENT -> vint [37:12]
    |       |--SEMI -> ; [37:16]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [38:8]
    |       |   |--MODIFIERS -> MODIFIERS [38:8]
    |       |   |--TYPE -> TYPE [38:8]
    |       |   |   `--IDENT -> Object [38:8]
    |       |   |--IDENT -> o [38:15]
    |       |   `--ASSIGN -> = [38:17]
    |       |       `--EXPR -> EXPR [38:19]
    |       |           `--LITERAL_NULL -> null [38:19]
    |       |--SEMI -> ; [38:23]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [39:8]
    |       |   |--MODIFIERS -> MODIFIERS [39:8]
    |       |   |--TYPE -> TYPE [39:8]
    |       |   |   |--IDENT -> List [39:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:12]
    |       |   |       |--GENERIC_START -> < [39:12]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:13]
    |       |   |       |   `--IDENT -> String [39:13]
    |       |   |       `--GENERIC_END -> > [39:19]
    |       |   `--IDENT -> vlist [39:21]
    |       |--SEMI -> ; [39:26]
    |       |--EXPR -> EXPR [40:14]
    |       |   `--ASSIGN -> = [40:14]
    |       |       |--IDENT -> vlist [40:8]
    |       |       `--LITERAL_NEW -> new [40:16]
    |       |           |--IDENT -> ArrayList [40:20]
    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:29]
    |       |           |   |--GENERIC_START -> < [40:29]
    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:30]
    |       |           |   |   `--IDENT -> String [40:30]
    |       |           |   `--GENERIC_END -> > [40:36]
    |       |           |--LPAREN -> ( [40:37]
    |       |           |--ELIST -> ELIST [40:38]
    |       |           `--RPAREN -> ) [40:38]
    |       |--SEMI -> ; [40:39]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [41:8]
    |       |   |--MODIFIERS -> MODIFIERS [41:8]
    |       |   |--TYPE -> TYPE [41:8]
    |       |   |   |--IDENT -> Supplier [41:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [41:16]
    |       |   |       |--GENERIC_START -> < [41:16]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [41:17]
    |       |   |       |   `--WILDCARD_TYPE -> ? [41:17]
    |       |   |       `--GENERIC_END -> > [41:18]
    |       |   `--IDENT -> s [41:20]
    |       |--SEMI -> ; [41:21]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [44:11]
    |       |   |--MODIFIERS -> MODIFIERS [44:11]
    |       |   |--TYPE -> TYPE [44:11]
    |       |   |   `--DOT -> . [44:11]
    |       |   |       |--IDENT -> Map [44:8]
    |       |   |       |--ANNOTATIONS -> ANNOTATIONS [44:12]
    |       |   |       |   `--ANNOTATION -> ANNOTATION [44:12]
    |       |   |       |       |--AT -> @ [44:12]
    |       |   |       |       `--IDENT -> Nullable [44:13]
    |       |   |       `--IDENT -> Entry [44:22]
    |       |   `--IDENT -> e [44:28]
    |       |--SEMI -> ; [44:29]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [45:8]
    |       |   |--MODIFIERS -> MODIFIERS [45:8]
    |       |   |--TYPE -> TYPE [45:8]
    |       |   |   `--IDENT -> String [45:8]
    |       |   |--IDENT -> str [45:15]
    |       |   `--ASSIGN -> = [45:19]
    |       |       `--EXPR -> EXPR [45:21]
    |       |           `--TYPECAST -> ( [45:21]
    |       |               |--TYPE -> TYPE [45:22]
    |       |               |   |--ANNOTATIONS -> ANNOTATIONS [45:22]
    |       |               |   |   `--ANNOTATION -> ANNOTATION [45:22]
    |       |               |   |       |--AT -> @ [45:22]
    |       |               |   |       `--IDENT -> Nullable [45:23]
    |       |               |   `--IDENT -> String [45:32]
    |       |               |--RPAREN -> ) [45:38]
    |       |               `--STRING_LITERAL -> "" [45:40]
    |       |--SEMI -> ; [45:42]
    |       |--EXPR -> EXPR [46:42]
    |       |   `--METHOD_CALL -> ( [46:42]
    |       |       |--DOT -> . [46:22]
    |       |       |   |--LPAREN -> ( [46:8]
    |       |       |   |--LITERAL_NEW -> new [46:9]
    |       |       |   |   |--IDENT -> Inner3 [46:13]
    |       |       |   |   |--LPAREN -> ( [46:19]
    |       |       |   |   |--ELIST -> ELIST [46:20]
    |       |       |   |   `--RPAREN -> ) [46:20]
    |       |       |   |--RPAREN -> ) [46:21]
    |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [46:23]
    |       |       |   |   |--GENERIC_START -> < [46:23]
    |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [46:24]
    |       |       |   |   |   |--ANNOTATIONS -> ANNOTATIONS [46:24]
    |       |       |   |   |   |   `--ANNOTATION -> ANNOTATION [46:24]
    |       |       |   |   |   |       |--AT -> @ [46:24]
    |       |       |   |   |   |       `--IDENT -> Nullable [46:25]
    |       |       |   |   |   `--IDENT -> String [46:34]
    |       |       |   |   `--GENERIC_END -> > [46:40]
    |       |       |   `--IDENT -> m [46:41]
    |       |       |--ELIST -> ELIST [46:43]
    |       |       `--RPAREN -> ) [46:43]
    |       |--SEMI -> ; [46:44]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [49:8]
    |       |   |--MODIFIERS -> MODIFIERS [49:8]
    |       |   |--TYPE -> TYPE [49:8]
    |       |   |   `--IDENT -> IntBinaryOperator [49:8]
    |       |   |--IDENT -> ibo [49:26]
    |       |   `--ASSIGN -> = [49:30]
    |       |       `--EXPR -> EXPR [49:36]
    |       |           `--METHOD_REF -> :: [49:36]
    |       |               |--IDENT -> Math [49:32]
    |       |               `--IDENT -> max [49:38]
    |       |--SEMI -> ; [49:41]
    |       |--EXPR -> EXPR [50:10]
    |       |   `--ASSIGN -> = [50:10]
    |       |       |--IDENT -> s [50:8]
    |       |       `--METHOD_REF -> :: [50:38]
    |       |           |--IDENT -> InputRegressionJava8Class1 [50:12]
    |       |           `--LITERAL_NEW -> new [50:40]
    |       |--SEMI -> ; [50:43]
    |       |--EXPR -> EXPR [51:10]
    |       |   `--ASSIGN -> = [51:10]
    |       |       |--IDENT -> s [51:8]
    |       |       `--METHOD_REF -> :: [51:33]
    |       |           |--DOT -> . [51:18]
    |       |           |   |--IDENT -> Inner1 [51:12]
    |       |           |   |--IDENT -> Inner2 [51:19]
    |       |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:25]
    |       |           |       |--GENERIC_START -> < [51:25]
    |       |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:26]
    |       |           |       |   `--IDENT -> String [51:26]
    |       |           |       `--GENERIC_END -> > [51:32]
    |       |           `--LITERAL_NEW -> new [51:35]
    |       |--SEMI -> ; [51:38]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [54:8]
    |       |   |--MODIFIERS -> MODIFIERS [54:8]
    |       |   |--TYPE -> TYPE [54:8]
    |       |   |   `--IDENT -> Runnable [54:8]
    |       |   |--IDENT -> r1 [54:17]
    |       |   `--ASSIGN -> = [54:20]
    |       |       `--LAMBDA -> -> [54:25]
    |       |           |--LPAREN -> ( [54:22]
    |       |           |--PARAMETERS -> PARAMETERS [54:23]
    |       |           |--RPAREN -> ) [54:23]
    |       |           `--EXPR -> EXPR [54:29]
    |       |               `--METHOD_CALL -> ( [54:29]
    |       |                   |--IDENT -> m [54:28]
    |       |                   |--ELIST -> ELIST [54:30]
    |       |                   `--RPAREN -> ) [54:30]
    |       |--SEMI -> ; [54:31]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [55:8]
    |       |   |--MODIFIERS -> MODIFIERS [55:8]
    |       |   |--TYPE -> TYPE [55:8]
    |       |   |   `--IDENT -> Runnable [55:8]
    |       |   |--IDENT -> r2 [55:17]
    |       |   `--ASSIGN -> = [55:20]
    |       |       `--LAMBDA -> -> [55:25]
    |       |           |--LPAREN -> ( [55:22]
    |       |           |--PARAMETERS -> PARAMETERS [55:23]
    |       |           |--RPAREN -> ) [55:23]
    |       |           `--SLIST -> { [55:28]
    |       |               |--EXPR -> EXPR [55:31]
    |       |               |   `--METHOD_CALL -> ( [55:31]
    |       |               |       |--IDENT -> m [55:30]
    |       |               |       |--ELIST -> ELIST [55:32]
    |       |               |       `--RPAREN -> ) [55:32]
    |       |               |--SEMI -> ; [55:33]
    |       |               `--RCURLY -> } [55:35]
    |       |--SEMI -> ; [55:37]
    |       |--EXPR -> EXPR [56:24]
    |       |   `--METHOD_CALL -> ( [56:24]
    |       |       |--DOT -> . [56:19]
    |       |       |   |--IDENT -> Collections [56:8]
    |       |       |   `--IDENT -> sort [56:20]
    |       |       |--ELIST -> ELIST [56:25]
    |       |       |   |--EXPR -> EXPR [56:25]
    |       |       |   |   `--IDENT -> vlist [56:25]
    |       |       |   |--COMMA -> , [56:30]
    |       |       |   `--LAMBDA -> -> [56:40]
    |       |       |       |--LPAREN -> ( [56:32]
    |       |       |       |--PARAMETERS -> PARAMETERS [56:33]
    |       |       |       |   |--PARAMETER_DEF -> PARAMETER_DEF [56:33]
    |       |       |       |   |   |--MODIFIERS -> MODIFIERS [56:33]
    |       |       |       |   |   |--TYPE -> TYPE [56:33]
    |       |       |       |   |   `--IDENT -> l [56:33]
    |       |       |       |   |--COMMA -> , [56:34]
    |       |       |       |   `--PARAMETER_DEF -> PARAMETER_DEF [56:37]
    |       |       |       |       |--MODIFIERS -> MODIFIERS [56:37]
    |       |       |       |       |--TYPE -> TYPE [56:37]
    |       |       |       |       `--IDENT -> r [56:37]
    |       |       |       |--RPAREN -> ) [56:38]
    |       |       |       `--EXPR -> EXPR [56:50]
    |       |       |           `--QUESTION -> ? [56:50]
    |       |       |               |--EQUAL -> == [56:45]
    |       |       |               |   |--IDENT -> l [56:43]
    |       |       |               |   `--IDENT -> r [56:48]
    |       |       |               |--NUM_INT -> 0 [56:52]
    |       |       |               |--COLON -> : [56:54]
    |       |       |               `--NUM_INT -> 1 [56:56]
    |       |       `--RPAREN -> ) [56:57]
    |       |--SEMI -> ; [56:58]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [57:8]
    |       |   |--MODIFIERS -> MODIFIERS [57:8]
    |       |   |--TYPE -> TYPE [57:8]
    |       |   |   |--IDENT -> Predicate [57:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [57:17]
    |       |   |       |--GENERIC_START -> < [57:17]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [57:18]
    |       |   |       |   `--WILDCARD_TYPE -> ? [57:18]
    |       |   |       `--GENERIC_END -> > [57:19]
    |       |   |--IDENT -> t [57:21]
    |       |   `--ASSIGN -> = [57:23]
    |       |       `--EXPR -> EXPR [57:29]
    |       |           `--QUESTION -> ? [57:29]
    |       |               |--LPAREN -> ( [57:25]
    |       |               |--IDENT -> b [57:26]
    |       |               |--RPAREN -> ) [57:27]
    |       |               |--LITERAL_NULL -> null [57:31]
    |       |               |--COLON -> : [57:36]
    |       |               `--LAMBDA -> -> [57:45]
    |       |                   |--IDENT -> object [57:38]
    |       |                   `--EXPR -> EXPR [57:56]
    |       |                       `--METHOD_CALL -> ( [57:56]
    |       |                           |--DOT -> . [57:49]
    |       |                           |   |--IDENT -> o [57:48]
    |       |                           |   `--IDENT -> equals [57:50]
    |       |                           |--ELIST -> ELIST [57:57]
    |       |                           |   `--EXPR -> EXPR [57:57]
    |       |                           |       `--IDENT -> object [57:57]
    |       |                           `--RPAREN -> ) [57:63]
    |       |--SEMI -> ; [57:64]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [58:8]
    |       |   |--MODIFIERS -> MODIFIERS [58:8]
    |       |   |--TYPE -> TYPE [58:8]
    |       |   |   `--IDENT -> Double [58:8]
    |       |   |--IDENT -> mPi [58:15]
    |       |   `--ASSIGN -> = [58:19]
    |       |       `--EXPR -> EXPR [58:25]
    |       |           `--DOT -> . [58:25]
    |       |               |--IDENT -> Math [58:21]
    |       |               `--IDENT -> PI [58:26]
    |       |--SEMI -> ; [58:28]
    |       `--RCURLY -> } [59:4]
    |--VARIABLE_DEF -> VARIABLE_DEF [61:4]
    |   |--MODIFIERS -> MODIFIERS [61:4]
    |   |   |--LITERAL_STATIC -> static [61:4]
    |   |   `--FINAL -> final [61:11]
    |   |--TYPE -> TYPE [61:17]
    |   |   |--IDENT -> Comparator [61:17]
    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [61:27]
    |   |       |--GENERIC_START -> < [61:27]
    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [61:28]
    |   |       |   `--WILDCARD_TYPE -> ? [61:28]
    |   |       `--GENERIC_END -> > [61:29]
    |   |--IDENT -> f [61:31]
    |   |--ASSIGN -> = [61:33]
    |   |   `--EXPR -> EXPR [61:35]
    |   |       `--TYPECAST -> ( [61:35]
    |   |           |--TYPE -> TYPE [61:36]
    |   |           |   |--IDENT -> Comparator [61:36]
    |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [61:46]
    |   |           |       |--GENERIC_START -> < [61:46]
    |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [61:47]
    |   |           |       |   `--WILDCARD_TYPE -> ? [61:47]
    |   |           |       `--GENERIC_END -> > [61:48]
    |   |           |--RPAREN -> ) [61:49]
    |   |           `--LAMBDA -> -> [61:74]
    |   |               |--LPAREN -> ( [61:51]
    |   |               |--PARAMETERS -> PARAMETERS [61:52]
    |   |               |   |--PARAMETER_DEF -> PARAMETER_DEF [61:52]
    |   |               |   |   |--MODIFIERS -> MODIFIERS [61:52]
    |   |               |   |   |--TYPE -> TYPE [61:52]
    |   |               |   |   `--IDENT -> dateTime1 [61:52]
    |   |               |   |--COMMA -> , [61:61]
    |   |               |   `--PARAMETER_DEF -> PARAMETER_DEF [61:63]
    |   |               |       |--MODIFIERS -> MODIFIERS [61:63]
    |   |               |       |--TYPE -> TYPE [61:63]
    |   |               |       `--IDENT -> dateTime2 [61:63]
    |   |               |--RPAREN -> ) [61:72]
    |   |               `--SLIST -> { [61:77]
    |   |                   |--LITERAL_RETURN -> return [61:79]
    |   |                   |   |--EXPR -> EXPR [61:86]
    |   |                   |   |   `--NUM_INT -> 0 [61:86]
    |   |                   |   `--SEMI -> ; [61:87]
    |   |                   `--RCURLY -> } [61:89]
    |   `--SEMI -> ; [61:90]
    |--CLASS_DEF -> CLASS_DEF [63:4]
    |   |--MODIFIERS -> MODIFIERS [63:4]
    |   |   `--LITERAL_PRIVATE -> private [63:4]
    |   |--LITERAL_CLASS -> class [63:12]
    |   |--IDENT -> Inner [63:18]
    |   `--OBJBLOCK -> OBJBLOCK [63:24]
    |       |--LCURLY -> { [63:24]
    |       |--CTOR_DEF -> CTOR_DEF [64:8]
    |       |   |--MODIFIERS -> MODIFIERS [64:8]
    |       |   |   `--LITERAL_PUBLIC -> public [64:8]
    |       |   |--IDENT -> Inner [64:15]
    |       |   |--LPAREN -> ( [64:20]
    |       |   |--PARAMETERS -> PARAMETERS [64:21]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [64:21]
    |       |   |       |--MODIFIERS -> MODIFIERS [64:21]
    |       |   |       |--TYPE -> TYPE [64:21]
    |       |   |       |   `--IDENT -> InputRegressionJava8Class1 [64:21]
    |       |   |       `--DOT -> . [64:74]
    |       |   |           |--IDENT -> InputRegressionJava8Class1 [64:48]
    |       |   |           `--LITERAL_THIS -> this [64:75]
    |       |   |--RPAREN -> ) [64:79]
    |       |   `--SLIST -> { [64:81]
    |       |       `--RCURLY -> } [64:82]
    |       `--RCURLY -> } [65:4]
    `--RCURLY -> } [66:0]
SEMI -> ; [67:0]
CLASS_DEF -> CLASS_DEF [68:0]
|--MODIFIERS -> MODIFIERS [68:0]
|--LITERAL_CLASS -> class [68:0]
|--IDENT -> InputRegressionJava8TypeParam [68:6]
|--TYPE_PARAMETERS -> TYPE_PARAMETERS [68:36]
|   |--GENERIC_START -> < [68:36]
|   |--TYPE_PARAMETER -> TYPE_PARAMETER [68:37]
|   |   |--ANNOTATIONS -> ANNOTATIONS [68:37]
|   |   |   `--ANNOTATION -> ANNOTATION [68:37]
|   |   |       |--AT -> @ [68:37]
|   |   |       `--IDENT -> Nullable [68:38]
|   |   `--IDENT -> T [68:47]
|   `--GENERIC_END -> > [68:48]
`--OBJBLOCK -> OBJBLOCK [68:50]
    |--LCURLY -> { [68:50]
    `--RCURLY -> } [69:0]
ANNOTATION_DEF -> ANNOTATION_DEF [70:0]
|--MODIFIERS -> MODIFIERS [70:0]
|   |--ANNOTATION -> ANNOTATION [70:0]
|   |   |--AT -> @ [70:0]
|   |   |--IDENT -> Retention [70:1]
|   |   |--LPAREN -> ( [70:10]
|   |   |--EXPR -> EXPR [70:26]
|   |   |   `--DOT -> . [70:26]
|   |   |       |--IDENT -> RetentionPolicy [70:11]
|   |   |       `--IDENT -> CLASS [70:27]
|   |   `--RPAREN -> ) [70:32]
|   `--ANNOTATION -> ANNOTATION [71:0]
|       |--AT -> @ [71:0]
|       |--IDENT -> Target [71:1]
|       |--LPAREN -> ( [71:7]
|       |--ANNOTATION_ARRAY_INIT -> { [71:8]
|       |   |--EXPR -> EXPR [71:21]
|       |   |   `--DOT -> . [71:21]
|       |   |       |--IDENT -> ElementType [71:10]
|       |   |       `--IDENT -> TYPE_USE [71:22]
|       |   `--RCURLY -> } [71:31]
|       `--RPAREN -> ) [71:32]
|--AT -> @ [72:0]
|--LITERAL_INTERFACE -> interface [72:1]
|--IDENT -> Nullable [72:11]
`--OBJBLOCK -> OBJBLOCK [72:20]
    |--LCURLY -> { [72:20]
    `--RCURLY -> } [73:0]