COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:40]
|   |--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]
|   `--SEMI -> ; [1:48]
|--IMPORT -> import [3:1]
|   |--DOT -> . [3:17]
|   |   |--DOT -> . [3:12]
|   |   |   |--IDENT -> java [3:8]
|   |   |   `--IDENT -> util [3:13]
|   |   `--IDENT -> ArrayList [3:18]
|   `--SEMI -> ; [3:27]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:17]
|   |   |--DOT -> . [4:12]
|   |   |   |--IDENT -> java [4:8]
|   |   |   `--IDENT -> util [4:13]
|   |   `--IDENT -> Collection [4:18]
|   `--SEMI -> ; [4:28]
|--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]
|--CLASS_DEF -> CLASS_DEF [7:1]
|   |--MODIFIERS -> MODIFIERS [7:1]
|   |   `--ANNOTATION -> ANNOTATION [7:1]
|   |       |--AT -> @ [7:1]
|   |       |--IDENT -> SuppressWarnings [7:2]
|   |       |--LPAREN -> ( [7:18]
|   |       |--EXPR -> EXPR [7:19]
|   |       |   `--STRING_LITERAL -> "serial" [7:19]
|   |       `--RPAREN -> ) [7:27]
|   |--LITERAL_CLASS -> class [8:1]
|   |--IDENT -> InputRegressionJavaClass2 [8:7]
|   |--EXTENDS_CLAUSE -> extends [8:33]
|   |   `--IDENT -> ArrayList [8:41]
|   |--IMPLEMENTS_CLAUSE -> implements [8:51]
|   |   |--IDENT -> List [8:62]
|   |   |--COMMA -> , [8:66]
|   |   `--IDENT -> Collection [8:68]
|   `--OBJBLOCK -> OBJBLOCK [8:79]
|       |--LCURLY -> { [8:79]
|       |--CTOR_DEF -> CTOR_DEF [9:5]
|       |   |--MODIFIERS -> MODIFIERS [9:5]
|       |   |   `--LITERAL_PUBLIC -> public [9:5]
|       |   |--IDENT -> InputRegressionJavaClass2 [9:12]
|       |   |--LPAREN -> ( [9:37]
|       |   |--PARAMETERS -> PARAMETERS [9:38]
|       |   |--RPAREN -> ) [9:38]
|       |   `--SLIST -> { [9:40]
|       |       |--SUPER_CTOR_CALL -> super [9:42]
|       |       |   |--LPAREN -> ( [9:47]
|       |       |   |--ELIST -> ELIST [9:48]
|       |       |   |--RPAREN -> ) [9:48]
|       |       |   `--SEMI -> ; [9:49]
|       |       `--RCURLY -> } [9:51]
|       |--METHOD_DEF -> METHOD_DEF [11:5]
|       |   |--MODIFIERS -> MODIFIERS [11:5]
|       |   |   |--ANNOTATION -> ANNOTATION [11:5]
|       |   |   |   |--AT -> @ [11:5]
|       |   |   |   `--IDENT -> Override [11:6]
|       |   |   `--LITERAL_PUBLIC -> public [12:5]
|       |   |--TYPE -> TYPE [12:12]
|       |   |   `--LITERAL_INT -> int [12:12]
|       |   |--IDENT -> size [12:16]
|       |   |--LPAREN -> ( [12:20]
|       |   |--PARAMETERS -> PARAMETERS [12:21]
|       |   |--RPAREN -> ) [12:21]
|       |   `--SLIST -> { [12:23]
|       |       |--LITERAL_RETURN -> return [12:25]
|       |       |   |--EXPR -> EXPR [12:42]
|       |       |   |   `--METHOD_CALL -> ( [12:42]
|       |       |   |       |--DOT -> . [12:37]
|       |       |   |       |   |--LITERAL_SUPER -> super [12:32]
|       |       |   |       |   `--IDENT -> size [12:38]
|       |       |   |       |--ELIST -> ELIST [12:43]
|       |       |   |       `--RPAREN -> ) [12:43]
|       |       |   `--SEMI -> ; [12:44]
|       |       `--RCURLY -> } [12:46]
|       |--METHOD_DEF -> METHOD_DEF [13:5]
|       |   |--MODIFIERS -> MODIFIERS [13:5]
|       |   |   |--ANNOTATION -> ANNOTATION [13:5]
|       |   |   |   |--AT -> @ [13:5]
|       |   |   |   |--IDENT -> Override [13:6]
|       |   |   |   |--LPAREN -> ( [13:14]
|       |   |   |   `--RPAREN -> ) [13:15]
|       |   |   `--LITERAL_PUBLIC -> public [14:5]
|       |   |--TYPE -> TYPE [14:12]
|       |   |   `--LITERAL_BOOLEAN -> boolean [14:12]
|       |   |--IDENT -> isEmpty [14:20]
|       |   |--LPAREN -> ( [14:27]
|       |   |--PARAMETERS -> PARAMETERS [14:28]
|       |   |--RPAREN -> ) [14:28]
|       |   `--SLIST -> { [14:30]
|       |       |--LITERAL_RETURN -> return [14:32]
|       |       |   |--EXPR -> EXPR [14:78]
|       |       |   |   `--METHOD_CALL -> ( [14:78]
|       |       |   |       |--DOT -> . [14:70]
|       |       |   |       |   |--DOT -> . [14:64]
|       |       |   |       |   |   |--IDENT -> InputRegressionJavaClass2 [14:39]
|       |       |   |       |   |   `--LITERAL_SUPER -> super [14:65]
|       |       |   |       |   `--IDENT -> isEmpty [14:71]
|       |       |   |       |--ELIST -> ELIST [14:79]
|       |       |   |       `--RPAREN -> ) [14:79]
|       |       |   `--SEMI -> ; [14:80]
|       |       `--RCURLY -> } [14:82]
|       |--CLASS_DEF -> CLASS_DEF [16:5]
|       |   |--MODIFIERS -> MODIFIERS [16:5]
|       |   |   `--LITERAL_PUBLIC -> public [16:5]
|       |   |--LITERAL_CLASS -> class [16:12]
|       |   |--IDENT -> Inner1 [16:18]
|       |   `--OBJBLOCK -> OBJBLOCK [16:25]
|       |       |--LCURLY -> { [16:25]
|       |       |--METHOD_DEF -> METHOD_DEF [17:9]
|       |       |   |--MODIFIERS -> MODIFIERS [17:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [17:9]
|       |       |   |--TYPE -> TYPE [17:16]
|       |       |   |   `--LITERAL_VOID -> void [17:16]
|       |       |   |--IDENT -> m [17:21]
|       |       |   |--LPAREN -> ( [17:22]
|       |       |   |--PARAMETERS -> PARAMETERS [17:23]
|       |       |   |--RPAREN -> ) [17:23]
|       |       |   `--SLIST -> { [17:25]
|       |       |       |--CLASS_DEF -> CLASS_DEF [18:13]
|       |       |       |   |--MODIFIERS -> MODIFIERS [18:13]
|       |       |       |   |--LITERAL_CLASS -> class [18:13]
|       |       |       |   |--IDENT -> Inner2 [18:19]
|       |       |       |   `--OBJBLOCK -> OBJBLOCK [18:26]
|       |       |       |       |--LCURLY -> { [18:26]
|       |       |       |       `--RCURLY -> } [19:13]
|       |       |       `--RCURLY -> } [20:9]
|       |       |--SEMI -> ; [20:10]
|       |       |--METHOD_DEF -> METHOD_DEF [22:9]
|       |       |   |--MODIFIERS -> MODIFIERS [22:9]
|       |       |   |   `--LITERAL_PUBLIC -> public [22:9]
|       |       |   |--TYPE -> TYPE [22:16]
|       |       |   |   `--IDENT -> InputRegressionJavaClass2 [22:16]
|       |       |   |--IDENT -> m2 [22:42]
|       |       |   |--LPAREN -> ( [22:44]
|       |       |   |--PARAMETERS -> PARAMETERS [22:45]
|       |       |   |--RPAREN -> ) [22:45]
|       |       |   `--SLIST -> { [22:47]
|       |       |       |--LITERAL_RETURN -> return [23:13]
|       |       |       |   |--EXPR -> EXPR [23:45]
|       |       |       |   |   `--DOT -> . [23:45]
|       |       |       |   |       |--IDENT -> InputRegressionJavaClass2 [23:20]
|       |       |       |   |       `--LITERAL_THIS -> this [23:46]
|       |       |       |   `--SEMI -> ; [23:50]
|       |       |       `--RCURLY -> } [24:9]
|       |       `--RCURLY -> } [25:5]
|       |--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 -> m [27:17]
|       |   |--LPAREN -> ( [27:18]
|       |   |--PARAMETERS -> PARAMETERS [27:19]
|       |   |--RPAREN -> ) [27:19]
|       |   `--SLIST -> { [27:21]
|       |       |--EXPR -> EXPR [27:42]
|       |       |   `--METHOD_CALL -> ( [27:42]
|       |       |       |--DOT -> . [27:40]
|       |       |       |   |--DOT -> . [27:27]
|       |       |       |   |   |--LITERAL_THIS -> this [27:23]
|       |       |       |   |   `--LITERAL_NEW -> new [27:28]
|       |       |       |   |       |--IDENT -> Inner1 [27:32]
|       |       |       |   |       |--LPAREN -> ( [27:38]
|       |       |       |   |       |--ELIST -> ELIST [27:39]
|       |       |       |   |       `--RPAREN -> ) [27:39]
|       |       |       |   `--IDENT -> m [27:41]
|       |       |       |--ELIST -> ELIST [27:43]
|       |       |       `--RPAREN -> ) [27:43]
|       |       |--SEMI -> ; [27:44]
|       |       `--RCURLY -> } [27:46]
|       `--RCURLY -> } [28:1]
|--CLASS_DEF -> CLASS_DEF [29:1]
|   |--MODIFIERS -> MODIFIERS [29:1]
|   |--LITERAL_CLASS -> class [29:1]
|   |--IDENT -> _c1 [29:7]
|   `--OBJBLOCK -> OBJBLOCK [29:11]
|       |--LCURLY -> { [29:11]
|       `--RCURLY -> } [29:12]
|--CLASS_DEF -> CLASS_DEF [30:1]
|   |--MODIFIERS -> MODIFIERS [30:1]
|   |   `--ABSTRACT -> abstract [30:1]
|   |--LITERAL_CLASS -> class [30:10]
|   |--IDENT -> c2 [30:16]
|   `--OBJBLOCK -> OBJBLOCK [30:19]
|       |--LCURLY -> { [30:19]
|       `--RCURLY -> } [30:20]
|--CLASS_DEF -> CLASS_DEF [31:1]
|   |--MODIFIERS -> MODIFIERS [31:1]
|   |--LITERAL_CLASS -> class [31:1]
|   |--IDENT -> c3 [31:7]
|   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [31:9]
|   |   |--GENERIC_START -> < [31:9]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [31:10]
|   |   |   `--IDENT -> A [31:10]
|   |   `--GENERIC_END -> > [31:11]
|   `--OBJBLOCK -> OBJBLOCK [31:13]
|       |--LCURLY -> { [31:13]
|       |--METHOD_DEF -> METHOD_DEF [31:15]
|       |   |--MODIFIERS -> MODIFIERS [31:15]
|       |   |   `--LITERAL_PUBLIC -> public [31:15]
|       |   |--TYPE -> TYPE [31:22]
|       |   |   |--IDENT -> c3 [31:22]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:24]
|       |   |       |--GENERIC_START -> < [31:24]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:25]
|       |   |       |   `--IDENT -> A [31:25]
|       |   |       `--GENERIC_END -> > [31:26]
|       |   |--IDENT -> m [31:28]
|       |   |--LPAREN -> ( [31:29]
|       |   |--PARAMETERS -> PARAMETERS [31:30]
|       |   |--RPAREN -> ) [31:30]
|       |   `--SLIST -> { [31:31]
|       |       |--LITERAL_RETURN -> return [31:32]
|       |       |   |--EXPR -> EXPR [31:39]
|       |       |   |   `--LITERAL_NULL -> null [31:39]
|       |       |   `--SEMI -> ; [31:43]
|       |       `--RCURLY -> } [31:44]
|       `--RCURLY -> } [31:46]
|--CLASS_DEF -> CLASS_DEF [32:1]
|   |--MODIFIERS -> MODIFIERS [32:1]
|   |--LITERAL_CLASS -> class [32:1]
|   |--IDENT -> c4 [32:7]
|   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [32:9]
|   |   |--GENERIC_START -> < [32:9]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [32:10]
|   |   |   `--IDENT -> A [32:10]
|   |   |--COMMA -> , [32:11]
|   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [32:12]
|   |   |   `--IDENT -> B [32:12]
|   |   `--GENERIC_END -> > [32:13]
|   |--EXTENDS_CLAUSE -> extends [32:15]
|   |   |--IDENT -> c3 [32:23]
|   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:25]
|   |       |--GENERIC_START -> < [32:25]
|   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:26]
|   |       |   `--IDENT -> A [32:26]
|   |       `--GENERIC_END -> > [32:27]
|   `--OBJBLOCK -> OBJBLOCK [32:29]
|       |--LCURLY -> { [32:29]
|       |--CLASS_DEF -> CLASS_DEF [33:5]
|       |   |--MODIFIERS -> MODIFIERS [33:5]
|       |   |--LITERAL_CLASS -> class [33:5]
|       |   |--IDENT -> c4a [33:11]
|       |   `--OBJBLOCK -> OBJBLOCK [33:15]
|       |       |--LCURLY -> { [33:15]
|       |       `--RCURLY -> } [33:16]
|       |--CTOR_DEF -> CTOR_DEF [35:5]
|       |   |--MODIFIERS -> MODIFIERS [35:5]
|       |   |   `--LITERAL_PUBLIC -> public [35:5]
|       |   |--IDENT -> c4 [35:12]
|       |   |--LPAREN -> ( [35:14]
|       |   |--PARAMETERS -> PARAMETERS [35:15]
|       |   |--RPAREN -> ) [35:15]
|       |   `--SLIST -> { [35:17]
|       |       |--SUPER_CTOR_CALL -> super [35:27]
|       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:19]
|       |       |   |   |--GENERIC_START -> < [35:19]
|       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:20]
|       |       |   |   |   `--IDENT -> String [35:20]
|       |       |   |   `--GENERIC_END -> > [35:26]
|       |       |   |--LPAREN -> ( [35:32]
|       |       |   |--ELIST -> ELIST [35:33]
|       |       |   |--RPAREN -> ) [35:33]
|       |       |   `--SEMI -> ; [35:34]
|       |       `--RCURLY -> } [35:36]
|       |--METHOD_DEF -> METHOD_DEF [36:5]
|       |   |--MODIFIERS -> MODIFIERS [36:5]
|       |   |   `--LITERAL_PUBLIC -> public [36:5]
|       |   |--TYPE -> TYPE [36:12]
|       |   |   |--IDENT -> c3 [36:12]
|       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:14]
|       |   |       |--GENERIC_START -> < [36:14]
|       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:15]
|       |   |       |   `--IDENT -> A [36:15]
|       |   |       `--GENERIC_END -> > [36:16]
|       |   |--IDENT -> m [36:18]
|       |   |--LPAREN -> ( [36:19]
|       |   |--PARAMETERS -> PARAMETERS [36:20]
|       |   |--RPAREN -> ) [36:20]
|       |   `--SLIST -> { [36:22]
|       |       |--LITERAL_RETURN -> return [36:24]
|       |       |   |--EXPR -> EXPR [36:41]
|       |       |   |   `--METHOD_CALL -> ( [36:41]
|       |       |   |       |--DOT -> . [36:36]
|       |       |   |       |   |--LITERAL_SUPER -> super [36:31]
|       |       |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:37]
|       |       |   |       |   |   |--GENERIC_START -> < [36:37]
|       |       |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:38]
|       |       |   |       |   |   |   `--IDENT -> A [36:38]
|       |       |   |       |   |   `--GENERIC_END -> > [36:39]
|       |       |   |       |   `--IDENT -> m [36:40]
|       |       |   |       |--ELIST -> ELIST [36:42]
|       |       |   |       `--RPAREN -> ) [36:42]
|       |       |   `--SEMI -> ; [36:43]
|       |       `--RCURLY -> } [36:45]
|       `--RCURLY -> } [37:1]
|--CLASS_DEF -> CLASS_DEF [38:1]
|   |--MODIFIERS -> MODIFIERS [38:1]
|   |--LITERAL_CLASS -> class [38:1]
|   |--IDENT -> c5 [38:7]
|   |--EXTENDS_CLAUSE -> extends [38:10]
|   |   `--DOT -> . [38:20]
|   |       |--IDENT -> c4 [38:18]
|   |       `--IDENT -> c4a [38:21]
|   `--OBJBLOCK -> OBJBLOCK [38:25]
|       |--LCURLY -> { [38:25]
|       |--CTOR_DEF -> CTOR_DEF [39:5]
|       |   |--MODIFIERS -> MODIFIERS [39:5]
|       |   |--IDENT -> c5 [39:5]
|       |   |--LPAREN -> ( [39:7]
|       |   |--PARAMETERS -> PARAMETERS [39:8]
|       |   |--RPAREN -> ) [39:8]
|       |   `--SLIST -> { [39:10]
|       |       |--SUPER_CTOR_CALL -> super [39:21]
|       |       |   |--LITERAL_NEW -> new [39:12]
|       |       |   |   |--IDENT -> c4 [39:16]
|       |       |   |   |--LPAREN -> ( [39:18]
|       |       |   |   |--ELIST -> ELIST [39:19]
|       |       |   |   `--RPAREN -> ) [39:19]
|       |       |   |--DOT -> . [39:20]
|       |       |   |--LPAREN -> ( [39:26]
|       |       |   |--ELIST -> ELIST [39:27]
|       |       |   |--RPAREN -> ) [39:27]
|       |       |   `--SEMI -> ; [39:28]
|       |       `--RCURLY -> } [39:30]
|       |--CTOR_DEF -> CTOR_DEF [40:5]
|       |   |--MODIFIERS -> MODIFIERS [40:5]
|       |   |--IDENT -> c5 [40:5]
|       |   |--LPAREN -> ( [40:7]
|       |   |--PARAMETERS -> PARAMETERS [40:8]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [40:8]
|       |   |       |--MODIFIERS -> MODIFIERS [40:8]
|       |   |       |--TYPE -> TYPE [40:8]
|       |   |       |   `--LITERAL_INT -> int [40:8]
|       |   |       `--IDENT -> a [40:12]
|       |   |--RPAREN -> ) [40:13]
|       |   `--SLIST -> { [40:15]
|       |       |--SUPER_CTOR_CALL -> super [40:34]
|       |       |   |--LITERAL_NEW -> new [40:17]
|       |       |   |   |--IDENT -> c4 [40:21]
|       |       |   |   |--LPAREN -> ( [40:23]
|       |       |   |   |--ELIST -> ELIST [40:24]
|       |       |   |   `--RPAREN -> ) [40:24]
|       |       |   |--DOT -> . [40:25]
|       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:26]
|       |       |   |   |--GENERIC_START -> < [40:26]
|       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:27]
|       |       |   |   |   `--IDENT -> String [40:27]
|       |       |   |   `--GENERIC_END -> > [40:33]
|       |       |   |--LPAREN -> ( [40:39]
|       |       |   |--ELIST -> ELIST [40:40]
|       |       |   |--RPAREN -> ) [40:40]
|       |       |   `--SEMI -> ; [40:41]
|       |       `--RCURLY -> } [40:43]
|       `--RCURLY -> } [41:1]
|--INTERFACE_DEF -> INTERFACE_DEF [42:1]
|   |--MODIFIERS -> MODIFIERS [42:1]
|   |--LITERAL_INTERFACE -> interface [42:1]
|   |--IDENT -> i1 [42:11]
|   `--OBJBLOCK -> OBJBLOCK [42:14]
|       |--LCURLY -> { [42:14]
|       `--RCURLY -> } [42:15]
`--CLASS_DEF -> CLASS_DEF [43:1]
    |--MODIFIERS -> MODIFIERS [43:1]
    |--LITERAL_CLASS -> class [43:1]
    |--IDENT -> c6 [43:7]
    |--TYPE_PARAMETERS -> TYPE_PARAMETERS [43:9]
    |   |--GENERIC_START -> < [43:9]
    |   |--TYPE_PARAMETER -> TYPE_PARAMETER [43:10]
    |   |   |--IDENT -> T [43:10]
    |   |   `--TYPE_UPPER_BOUNDS -> extends [43:12]
    |   |       |--IDENT -> c3 [43:20]
    |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [43:22]
    |   |       |   |--GENERIC_START -> < [43:22]
    |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:23]
    |   |       |   |   `--IDENT -> T [43:23]
    |   |       |   `--GENERIC_END -> > [43:24]
    |   |       |--TYPE_EXTENSION_AND -> & [43:26]
    |   |       `--IDENT -> i1 [43:28]
    |   `--GENERIC_END -> > [43:30]
    `--OBJBLOCK -> OBJBLOCK [43:32]
        |--LCURLY -> { [43:32]
        `--RCURLY -> } [43:33]
