COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
|   |--ANNOTATIONS -> ANNOTATIONS [1:48]
|   |--DOT -> . [1:48]
|   |   |--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]
|   |   `--IDENT -> antlr4 [1:49]
|   `--SEMI -> ; [1:55]
|--IMPORT -> import [3:1]
|   |--DOT -> . [3:28]
|   |   |--DOT -> . [3:17]
|   |   |   |--DOT -> . [3:12]
|   |   |   |   |--IDENT -> java [3:8]
|   |   |   |   `--IDENT -> lang [3:13]
|   |   |   `--IDENT -> annotation [3:18]
|   |   `--IDENT -> ElementType [3:29]
|   `--SEMI -> ; [3:40]
|--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 -> Target [4:29]
|   `--SEMI -> ; [4:35]
|--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]
|--IMPORT -> import [6:1]
|   |--DOT -> . [6:17]
|   |   |--DOT -> . [6:12]
|   |   |   |--IDENT -> java [6:8]
|   |   |   `--IDENT -> util [6:13]
|   |   `--IDENT -> Map [6:18]
|   `--SEMI -> ; [6:21]
`--CLASS_DEF -> CLASS_DEF [8:1]
    |--MODIFIERS -> MODIFIERS [8:1]
    |   `--LITERAL_PUBLIC -> public [8:1]
    |--LITERAL_CLASS -> class [8:8]
    |--IDENT -> InputAntlr4AstRegressionSuppressWarnings [8:14]
    `--OBJBLOCK -> OBJBLOCK [8:55]
        |--LCURLY -> { [8:55]
        |--METHOD_DEF -> METHOD_DEF [10:5]
        |   |--MODIFIERS -> MODIFIERS [10:5]
        |   |   |--LITERAL_PUBLIC -> public [10:5]
        |   |   `--LITERAL_STATIC -> static [10:12]
        |   |--TYPE -> TYPE [10:19]
        |   |   `--IDENT -> Object [10:19]
        |   |--IDENT -> foo1 [10:26]
        |   |--LPAREN -> ( [10:30]
        |   |--PARAMETERS -> PARAMETERS [10:31]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:31]
        |   |       |--MODIFIERS -> MODIFIERS [10:31]
        |   |       |   `--ANNOTATION -> ANNOTATION [10:31]
        |   |       |       |--AT -> @ [10:31]
        |   |       |       |--IDENT -> SuppressWarnings [10:32]
        |   |       |       |--LPAREN -> ( [10:48]
        |   |       |       |--EXPR -> EXPR [10:49]
        |   |       |       |   `--STRING_LITERAL -> "unused" [10:49]
        |   |       |       `--RPAREN -> ) [10:57]
        |   |       |--TYPE -> TYPE [10:59]
        |   |       |   `--IDENT -> Object [10:59]
        |   |       `--IDENT -> str [10:66]
        |   |--RPAREN -> ) [10:69]
        |   `--SLIST -> { [10:71]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [11:9]
        |       |   |--MODIFIERS -> MODIFIERS [11:9]
        |       |   |--TYPE -> TYPE [11:9]
        |       |   |   `--IDENT -> String [11:9]
        |       |   |--IDENT -> myString [11:16]
        |       |   `--ASSIGN -> = [11:25]
        |       |       `--EXPR -> EXPR [11:27]
        |       |           `--TYPECAST -> ( [11:27]
        |       |               |--TYPE -> TYPE [11:28]
        |       |               |   |--ANNOTATIONS -> ANNOTATIONS [11:28]
        |       |               |   |   `--ANNOTATION -> ANNOTATION [11:28]
        |       |               |   |       |--AT -> @ [11:28]
        |       |               |   |       |--IDENT -> SuppressWarnings [11:29]
        |       |               |   |       |--LPAREN -> ( [11:45]
        |       |               |   |       |--EXPR -> EXPR [11:46]
        |       |               |   |       |   `--STRING_LITERAL -> "unused" [11:46]
        |       |               |   |       `--RPAREN -> ) [11:54]
        |       |               |   `--IDENT -> String [11:56]
        |       |               |--RPAREN -> ) [11:62]
        |       |               `--IDENT -> str [11:64]
        |       |--SEMI -> ; [11:67]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [12:9]
        |       |   |--MODIFIERS -> MODIFIERS [12:9]
        |       |   |--TYPE -> TYPE [12:9]
        |       |   |   `--IDENT -> Object [12:9]
        |       |   |--IDENT -> object [12:16]
        |       |   `--ASSIGN -> = [12:23]
        |       |       `--EXPR -> EXPR [12:25]
        |       |           `--LITERAL_NEW -> new [12:25]
        |       |               |--ANNOTATIONS -> ANNOTATIONS [12:29]
        |       |               |   `--ANNOTATION -> ANNOTATION [12:29]
        |       |               |       |--AT -> @ [12:29]
        |       |               |       |--IDENT -> SuppressWarnings [12:30]
        |       |               |       |--LPAREN -> ( [12:46]
        |       |               |       |--EXPR -> EXPR [12:47]
        |       |               |       |   `--STRING_LITERAL -> "unused" [12:47]
        |       |               |       `--RPAREN -> ) [12:55]
        |       |               |--IDENT -> Object [12:57]
        |       |               |--LPAREN -> ( [12:63]
        |       |               |--ELIST -> ELIST [12:64]
        |       |               `--RPAREN -> ) [12:64]
        |       |--SEMI -> ; [12:65]
        |       |--LITERAL_TRY -> try [13:9]
        |       |   |--SLIST -> { [13:13]
        |       |   |   |--LITERAL_RETURN -> return [14:13]
        |       |   |   |   |--EXPR -> EXPR [14:20]
        |       |   |   |   |   `--LITERAL_NULL -> null [14:20]
        |       |   |   |   `--SEMI -> ; [14:24]
        |       |   |   `--RCURLY -> } [16:9]
        |       |   `--LITERAL_CATCH -> catch [16:11]
        |       |       |--LPAREN -> ( [16:17]
        |       |       |--PARAMETER_DEF -> PARAMETER_DEF [16:18]
        |       |       |   |--MODIFIERS -> MODIFIERS [16:18]
        |       |       |   |   `--ANNOTATION -> ANNOTATION [16:18]
        |       |       |   |       |--AT -> @ [16:18]
        |       |       |   |       |--IDENT -> SuppressWarnings [16:19]
        |       |       |   |       |--LPAREN -> ( [16:35]
        |       |       |   |       |--EXPR -> EXPR [16:36]
        |       |       |   |       |   `--STRING_LITERAL -> "unused" [16:36]
        |       |       |   |       `--RPAREN -> ) [16:44]
        |       |       |   |--TYPE -> TYPE [16:46]
        |       |       |   |   `--IDENT -> Exception [16:46]
        |       |       |   `--IDENT -> ex [16:56]
        |       |       |--RPAREN -> ) [16:58]
        |       |       `--SLIST -> { [16:60]
        |       |           |--LITERAL_RETURN -> return [17:13]
        |       |           |   |--EXPR -> EXPR [17:20]
        |       |           |   |   `--STRING_LITERAL -> "" [17:20]
        |       |           |   `--SEMI -> ; [17:22]
        |       |           `--RCURLY -> } [18:9]
        |       `--RCURLY -> } [19:5]
        |--METHOD_DEF -> METHOD_DEF [21:5]
        |   |--MODIFIERS -> MODIFIERS [21:5]
        |   |--TYPE -> TYPE [21:5]
        |   |   `--LITERAL_VOID -> void [21:5]
        |   |--IDENT -> foo2 [21:10]
        |   |--LPAREN -> ( [21:14]
        |   |--PARAMETERS -> PARAMETERS [21:15]
        |   |--RPAREN -> ) [21:15]
        |   |--LITERAL_THROWS -> throws [21:17]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [21:24]
        |   |   |   `--ANNOTATION -> ANNOTATION [21:24]
        |   |   |       |--AT -> @ [21:24]
        |   |   |       |--IDENT -> SuppressWarnings [21:25]
        |   |   |       |--LPAREN -> ( [21:41]
        |   |   |       |--EXPR -> EXPR [21:42]
        |   |   |       |   `--STRING_LITERAL -> "unused" [21:42]
        |   |   |       `--RPAREN -> ) [21:50]
        |   |   `--IDENT -> Exception [21:52]
        |   `--SLIST -> { [21:62]
        |       `--RCURLY -> } [21:65]
        |--METHOD_DEF -> METHOD_DEF [23:5]
        |   |--MODIFIERS -> MODIFIERS [23:5]
        |   |   `--LITERAL_PUBLIC -> public [23:5]
        |   |--TYPE -> TYPE [23:12]
        |   |   `--LITERAL_VOID -> void [23:12]
        |   |--IDENT -> foo3 [23:17]
        |   |--LPAREN -> ( [23:21]
        |   |--PARAMETERS -> PARAMETERS [23:22]
        |   |--RPAREN -> ) [23:22]
        |   `--SLIST -> { [23:24]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [24:12]
        |       |   |--MODIFIERS -> MODIFIERS [24:12]
        |       |   |--TYPE -> TYPE [24:12]
        |       |   |   `--DOT -> . [24:12]
        |       |   |       |--IDENT -> Map [24:9]
        |       |   |       |--ANNOTATIONS -> ANNOTATIONS [24:13]
        |       |   |       |   `--ANNOTATION -> ANNOTATION [24:13]
        |       |   |       |       |--AT -> @ [24:13]
        |       |   |       |       |--IDENT -> SuppressWarnings [24:14]
        |       |   |       |       |--LPAREN -> ( [24:30]
        |       |   |       |       |--EXPR -> EXPR [24:31]
        |       |   |       |       |   `--STRING_LITERAL -> "unused" [24:31]
        |       |   |       |       `--RPAREN -> ) [24:39]
        |       |   |       `--IDENT -> Entry [24:41]
        |       |   `--IDENT -> entry [24:47]
        |       |--SEMI -> ; [24:52]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [25:9]
        |       |   |--MODIFIERS -> MODIFIERS [25:9]
        |       |   |--TYPE -> TYPE [25:9]
        |       |   |   `--IDENT -> MyObject [25:9]
        |       |   |--IDENT -> myObject [25:18]
        |       |   `--ASSIGN -> = [25:27]
        |       |       `--EXPR -> EXPR [25:29]
        |       |           `--LITERAL_NEW -> new [25:29]
        |       |               |--IDENT -> MyObject [25:33]
        |       |               |--LPAREN -> ( [25:41]
        |       |               |--ELIST -> ELIST [25:42]
        |       |               `--RPAREN -> ) [25:42]
        |       |--SEMI -> ; [25:43]
        |       |--EXPR -> EXPR [26:62]
        |       |   `--METHOD_CALL -> ( [26:62]
        |       |       |--DOT -> . [26:17]
        |       |       |   |--IDENT -> myObject [26:9]
        |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [26:18]
        |       |       |   |   |--GENERIC_START -> < [26:18]
        |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [26:19]
        |       |       |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:19]
        |       |       |   |   |   |   `--ANNOTATION -> ANNOTATION [26:19]
        |       |       |   |   |   |       |--AT -> @ [26:19]
        |       |       |   |   |   |       |--IDENT -> SuppressWarnings [26:20]
        |       |       |   |   |   |       |--LPAREN -> ( [26:36]
        |       |       |   |   |   |       |--EXPR -> EXPR [26:37]
        |       |       |   |   |   |       |   `--STRING_LITERAL -> "unused" [26:37]
        |       |       |   |   |   |       `--RPAREN -> ) [26:45]
        |       |       |   |   |   `--IDENT -> String [26:47]
        |       |       |   |   `--GENERIC_END -> > [26:53]
        |       |       |   `--IDENT -> myMethod [26:54]
        |       |       |--ELIST -> ELIST [26:63]
        |       |       `--RPAREN -> ) [26:63]
        |       |--SEMI -> ; [26:64]
        |       |--EXPR -> EXPR [27:17]
        |       |   `--DOT -> . [27:17]
        |       |       |--IDENT -> myObject [27:9]
        |       |       `--LITERAL_NEW -> new [27:18]
        |       |           |--ANNOTATIONS -> ANNOTATIONS [27:22]
        |       |           |   `--ANNOTATION -> ANNOTATION [27:22]
        |       |           |       |--AT -> @ [27:22]
        |       |           |       |--IDENT -> SuppressWarnings [27:23]
        |       |           |       |--LPAREN -> ( [27:39]
        |       |           |       |--EXPR -> EXPR [27:40]
        |       |           |       |   `--STRING_LITERAL -> "unused" [27:40]
        |       |           |       `--RPAREN -> ) [27:48]
        |       |           |--IDENT -> MyObject2 [27:50]
        |       |           |--LPAREN -> ( [27:59]
        |       |           |--ELIST -> ELIST [27:60]
        |       |           `--RPAREN -> ) [27:60]
        |       |--SEMI -> ; [27:61]
        |       `--RCURLY -> } [28:5]
        |--METHOD_DEF -> METHOD_DEF [30:5]
        |   |--MODIFIERS -> MODIFIERS [30:5]
        |   |   |--LITERAL_PUBLIC -> public [30:5]
        |   |   `--LITERAL_STATIC -> static [30:12]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [30:19]
        |   |   |--GENERIC_START -> < [30:19]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [30:20]
        |   |   |   `--IDENT -> T [30:20]
        |   |   `--GENERIC_END -> > [30:21]
        |   |--TYPE -> TYPE [30:23]
        |   |   `--LITERAL_VOID -> void [30:23]
        |   |--IDENT -> foo4 [30:28]
        |   |--LPAREN -> ( [30:32]
        |   |--PARAMETERS -> PARAMETERS [30:33]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [30:33]
        |   |       |--MODIFIERS -> MODIFIERS [30:33]
        |   |       |--TYPE -> TYPE [30:33]
        |   |       |   `--IDENT -> Object [30:33]
        |   |       `--IDENT -> str [30:40]
        |   |--RPAREN -> ) [30:43]
        |   `--SLIST -> { [30:45]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [31:9]
        |       |   |--MODIFIERS -> MODIFIERS [31:9]
        |       |   |--TYPE -> TYPE [31:9]
        |       |   |   |--IDENT -> List [31:9]
        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:13]
        |       |   |       |--GENERIC_START -> < [31:13]
        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:14]
        |       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [31:14]
        |       |   |       |   |   `--ANNOTATION -> ANNOTATION [31:14]
        |       |   |       |   |       |--AT -> @ [31:14]
        |       |   |       |   |       |--IDENT -> SuppressWarnings [31:15]
        |       |   |       |   |       |--LPAREN -> ( [31:31]
        |       |   |       |   |       |--EXPR -> EXPR [31:32]
        |       |   |       |   |       |   `--STRING_LITERAL -> "unused" [31:32]
        |       |   |       |   |       `--RPAREN -> ) [31:40]
        |       |   |       |   |--WILDCARD_TYPE -> ? [31:42]
        |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [31:44]
        |       |   |       |       |--IDENT -> Comparable [31:52]
        |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:62]
        |       |   |       |           |--GENERIC_START -> < [31:62]
        |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:63]
        |       |   |       |           |   `--IDENT -> T [31:63]
        |       |   |       |           `--GENERIC_END -> > [31:64]
        |       |   |       `--GENERIC_END -> > [31:65]
        |       |   `--IDENT -> unchangeable [31:67]
        |       |--SEMI -> ; [31:79]
        |       `--RCURLY -> } [32:5]
        |--CLASS_DEF -> CLASS_DEF [34:5]
        |   |--MODIFIERS -> MODIFIERS [34:5]
        |   |   `--ABSTRACT -> abstract [34:5]
        |   |--LITERAL_CLASS -> class [34:14]
        |   |--IDENT -> UnmodifiableList [34:20]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [34:36]
        |   |   |--GENERIC_START -> < [34:36]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [34:37]
        |   |   |   `--IDENT -> T [34:37]
        |   |   `--GENERIC_END -> > [34:38]
        |   |--IMPLEMENTS_CLAUSE -> implements [35:5]
        |   |   |--ANNOTATIONS -> ANNOTATIONS [35:16]
        |   |   |   `--ANNOTATION -> ANNOTATION [35:16]
        |   |   |       |--AT -> @ [35:16]
        |   |   |       |--IDENT -> SuppressWarnings [35:17]
        |   |   |       |--LPAREN -> ( [35:33]
        |   |   |       |--EXPR -> EXPR [35:34]
        |   |   |       |   `--STRING_LITERAL -> "unused" [35:34]
        |   |   |       `--RPAREN -> ) [35:42]
        |   |   |--IDENT -> List [35:43]
        |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:47]
        |   |       |--GENERIC_START -> < [35:47]
        |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:48]
        |   |       |   |--ANNOTATIONS -> ANNOTATIONS [35:48]
        |   |       |   |   `--ANNOTATION -> ANNOTATION [35:48]
        |   |       |   |       |--AT -> @ [35:48]
        |   |       |   |       |--IDENT -> SuppressWarnings [35:49]
        |   |       |   |       |--LPAREN -> ( [35:65]
        |   |       |   |       |--EXPR -> EXPR [35:66]
        |   |       |   |       |   `--STRING_LITERAL -> "unused" [35:66]
        |   |       |   |       `--RPAREN -> ) [35:74]
        |   |       |   `--IDENT -> T [35:76]
        |   |       `--GENERIC_END -> > [35:77]
        |   `--OBJBLOCK -> OBJBLOCK [35:79]
        |       |--LCURLY -> { [35:79]
        |       `--RCURLY -> } [36:5]
        |--CLASS_DEF -> CLASS_DEF [38:5]
        |   |--MODIFIERS -> MODIFIERS [38:5]
        |   |--LITERAL_CLASS -> class [38:5]
        |   |--IDENT -> MyObject [38:11]
        |   `--OBJBLOCK -> OBJBLOCK [38:19]
        |       |--LCURLY -> { [38:19]
        |       |--METHOD_DEF -> METHOD_DEF [40:9]
        |       |   |--MODIFIERS -> MODIFIERS [40:9]
        |       |   |   `--LITERAL_PUBLIC -> public [40:9]
        |       |   |--TYPE -> TYPE [40:16]
        |       |   |   `--LITERAL_VOID -> void [40:16]
        |       |   |--IDENT -> myMethod [40:21]
        |       |   |--LPAREN -> ( [40:29]
        |       |   |--PARAMETERS -> PARAMETERS [40:30]
        |       |   |--RPAREN -> ) [40:30]
        |       |   `--SLIST -> { [40:31]
        |       |       `--RCURLY -> } [40:32]
        |       |--SEMI -> ; [40:33]
        |       |--CLASS_DEF -> CLASS_DEF [42:9]
        |       |   |--MODIFIERS -> MODIFIERS [42:9]
        |       |   |--LITERAL_CLASS -> class [42:9]
        |       |   |--IDENT -> MyObject2 [42:15]
        |       |   `--OBJBLOCK -> OBJBLOCK [42:24]
        |       |       |--LCURLY -> { [42:24]
        |       |       `--RCURLY -> } [42:25]
        |       `--RCURLY -> } [43:5]
        |--ANNOTATION_DEF -> ANNOTATION_DEF [45:5]
        |   |--MODIFIERS -> MODIFIERS [45:5]
        |   |   `--ANNOTATION -> ANNOTATION [45:5]
        |   |       |--AT -> @ [45:5]
        |   |       |--IDENT -> Target [45:6]
        |   |       |--LPAREN -> ( [45:12]
        |   |       |--EXPR -> EXPR [45:24]
        |   |       |   `--DOT -> . [45:24]
        |   |       |       |--IDENT -> ElementType [45:13]
        |   |       |       `--IDENT -> TYPE_USE [45:25]
        |   |       `--RPAREN -> ) [45:33]
        |   |--AT -> @ [46:5]
        |   |--LITERAL_INTERFACE -> interface [46:6]
        |   |--IDENT -> SuppressWarnings [46:16]
        |   `--OBJBLOCK -> OBJBLOCK [46:33]
        |       |--LCURLY -> { [46:33]
        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [47:9]
        |       |   |--MODIFIERS -> MODIFIERS [47:9]
        |       |   |--TYPE -> TYPE [47:9]
        |       |   |   `--IDENT -> String [47:9]
        |       |   |--IDENT -> value [47:16]
        |       |   |--LPAREN -> ( [47:21]
        |       |   |--RPAREN -> ) [47:22]
        |       |   `--SEMI -> ; [47:23]
        |       `--RCURLY -> } [48:5]
        `--RCURLY -> } [49:1]
