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:17]
|   |   |--DOT -> . [3:12]
|   |   |   |--IDENT -> java [3:8]
|   |   |   `--IDENT -> util [3:13]
|   |   `--IDENT -> Iterator [3:18]
|   `--SEMI -> ; [3:26]
|--IMPORT -> import [4:1]
|   |--DOT -> . [4:26]
|   |   |--DOT -> . [4:17]
|   |   |   |--DOT -> . [4:12]
|   |   |   |   |--IDENT -> java [4:8]
|   |   |   |   `--IDENT -> util [4:13]
|   |   |   `--IDENT -> function [4:18]
|   |   `--IDENT -> Function [4:27]
|   `--SEMI -> ; [4:35]
`--CLASS_DEF -> CLASS_DEF [6:1]
    |--MODIFIERS -> MODIFIERS [6:1]
    |   `--LITERAL_PUBLIC -> public [6:1]
    |--LITERAL_CLASS -> class [6:8]
    |--IDENT -> InputAntlr4AstRegressionTrickyYield [6:14]
    |--TYPE_PARAMETERS -> TYPE_PARAMETERS [6:49]
    |   |--GENERIC_START -> < [6:49]
    |   |--TYPE_PARAMETER -> TYPE_PARAMETER [6:50]
    |   |   `--IDENT -> T1 [6:50]
    |   `--GENERIC_END -> > [6:52]
    `--OBJBLOCK -> OBJBLOCK [6:54]
        |--LCURLY -> { [6:54]
        |--METHOD_DEF -> METHOD_DEF [7:5]
        |   |--MODIFIERS -> MODIFIERS [7:5]
        |   |   `--LITERAL_PUBLIC -> public [7:5]
        |   |--TYPE -> TYPE [7:12]
        |   |   |--IDENT -> Iterator [7:12]
        |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:20]
        |   |       |--GENERIC_START -> < [7:20]
        |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:21]
        |   |       |   `--IDENT -> T1 [7:21]
        |   |       `--GENERIC_END -> > [7:23]
        |   |--IDENT -> yield [7:25]
        |   |--LPAREN -> ( [7:30]
        |   |--PARAMETERS -> PARAMETERS [7:31]
        |   |--RPAREN -> ) [7:31]
        |   `--SLIST -> { [7:33]
        |       |--LITERAL_RETURN -> return [8:9]
        |       |   |--EXPR -> EXPR [8:26]
        |       |   |   `--METHOD_CALL -> ( [8:26]
        |       |   |       |--DOT -> . [8:20]
        |       |   |       |   |--LITERAL_THIS -> this [8:16]
        |       |   |       |   `--IDENT -> yield [8:21]
        |       |   |       |--ELIST -> ELIST [8:44]
        |       |   |       |   `--EXPR -> EXPR [8:44]
        |       |   |       |       `--METHOD_CALL -> ( [8:44]
        |       |   |       |           |--DOT -> . [8:35]
        |       |   |       |           |   |--IDENT -> Function [8:27]
        |       |   |       |           |   `--IDENT -> identity [8:36]
        |       |   |       |           |--ELIST -> ELIST [8:45]
        |       |   |       |           `--RPAREN -> ) [8:45]
        |       |   |       `--RPAREN -> ) [8:46]
        |       |   `--SEMI -> ; [8:47]
        |       `--RCURLY -> } [9:5]
        |--METHOD_DEF -> METHOD_DEF [11:5]
        |   |--MODIFIERS -> MODIFIERS [11:5]
        |   |   |--LITERAL_PRIVATE -> private [11:5]
        |   |   `--LITERAL_STATIC -> static [11:13]
        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [11:20]
        |   |   |--GENERIC_START -> < [11:20]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:21]
        |   |   |   `--IDENT -> T [11:21]
        |   |   |--COMMA -> , [11:22]
        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:24]
        |   |   |   `--IDENT -> T1 [11:24]
        |   |   `--GENERIC_END -> > [11:26]
        |   |--TYPE -> TYPE [11:28]
        |   |   |--IDENT -> Iterator [11:28]
        |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:36]
        |   |       |--GENERIC_START -> < [11:36]
        |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:37]
        |   |       |   `--IDENT -> T1 [11:37]
        |   |       `--GENERIC_END -> > [11:39]
        |   |--IDENT -> yield [11:41]
        |   |--LPAREN -> ( [11:46]
        |   |--PARAMETERS -> PARAMETERS [11:47]
        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [11:47]
        |   |       |--MODIFIERS -> MODIFIERS [11:47]
        |   |       |--TYPE -> TYPE [11:47]
        |   |       |   |--IDENT -> Function [11:47]
        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:55]
        |   |       |       |--GENERIC_START -> < [11:55]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:56]
        |   |       |       |   `--IDENT -> T [11:56]
        |   |       |       |--COMMA -> , [11:57]
        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:58]
        |   |       |       |   `--IDENT -> T [11:58]
        |   |       |       `--GENERIC_END -> > [11:59]
        |   |       `--IDENT -> identity [11:61]
        |   |--RPAREN -> ) [11:69]
        |   `--SLIST -> { [11:71]
        |       |--LITERAL_RETURN -> return [12:9]
        |       |   |--EXPR -> EXPR [12:16]
        |       |   |   `--LITERAL_NULL -> null [12:16]
        |       |   `--SEMI -> ; [12:20]
        |       `--RCURLY -> } [13:5]
        `--RCURLY -> } [14:1]
