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