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