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]
`--CLASS_DEF -> CLASS_DEF [3:1]
    |--MODIFIERS -> MODIFIERS [3:1]
    |   `--LITERAL_PUBLIC -> public [3:1]
    |--LITERAL_CLASS -> class [3:8]
    |--IDENT -> InputAntlr4AstRegressionMethodCall [3:14]
    `--OBJBLOCK -> OBJBLOCK [3:49]
        |--LCURLY -> { [3:49]
        |--CLASS_DEF -> CLASS_DEF [4:5]
        |   |--MODIFIERS -> MODIFIERS [4:5]
        |   |   |--LITERAL_PUBLIC -> public [4:5]
        |   |   `--LITERAL_STATIC -> static [4:12]
        |   |--LITERAL_CLASS -> class [4:19]
        |   |--IDENT -> IntData [4:25]
        |   `--OBJBLOCK -> OBJBLOCK [4:33]
        |       |--LCURLY -> { [4:33]
        |       |--VARIABLE_DEF -> VARIABLE_DEF [5:9]
        |       |   |--MODIFIERS -> MODIFIERS [5:9]
        |       |   |--TYPE -> TYPE [5:9]
        |       |   |   |--LITERAL_INT -> int [5:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [5:12]
        |       |   |       `--RBRACK -> ] [5:13]
        |       |   |--IDENT -> xorData [5:15]
        |       |   `--SEMI -> ; [5:22]
        |       |--CTOR_DEF -> CTOR_DEF [7:9]
        |       |   |--MODIFIERS -> MODIFIERS [7:9]
        |       |   |--IDENT -> IntData [7:9]
        |       |   |--LPAREN -> ( [7:16]
        |       |   |--PARAMETERS -> PARAMETERS [7:17]
        |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [7:17]
        |       |   |   |   |--MODIFIERS -> MODIFIERS [7:17]
        |       |   |   |   |--TYPE -> TYPE [7:17]
        |       |   |   |   |   `--IDENT -> Object [7:17]
        |       |   |   |   `--IDENT -> srcPixel [7:24]
        |       |   |   |--COMMA -> , [7:32]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [7:34]
        |       |   |       |--MODIFIERS -> MODIFIERS [7:34]
        |       |   |       |--TYPE -> TYPE [7:34]
        |       |   |       |   `--IDENT -> Object [7:34]
        |       |   |       `--IDENT -> xorPixel [7:41]
        |       |   |--RPAREN -> ) [7:49]
        |       |   `--SLIST -> { [7:51]
        |       |       |--EXPR -> EXPR [8:26]
        |       |       |   `--ASSIGN -> = [8:26]
        |       |       |       |--DOT -> . [8:17]
        |       |       |       |   |--LITERAL_THIS -> this [8:13]
        |       |       |       |   `--IDENT -> xorData [8:18]
        |       |       |       `--TYPECAST -> ( [8:28]
        |       |       |           |--TYPE -> TYPE [8:29]
        |       |       |           |   |--LITERAL_INT -> int [8:29]
        |       |       |           |   `--ARRAY_DECLARATOR -> [ [8:32]
        |       |       |           |       `--RBRACK -> ] [8:33]
        |       |       |           |--RPAREN -> ) [8:34]
        |       |       |           `--IDENT -> srcPixel [8:36]
        |       |       |--SEMI -> ; [8:44]
        |       |       |--EXPR -> EXPR [9:26]
        |       |       |   `--ASSIGN -> = [9:26]
        |       |       |       |--DOT -> . [9:17]
        |       |       |       |   |--LITERAL_THIS -> this [9:13]
        |       |       |       |   `--IDENT -> xorData [9:18]
        |       |       |       `--TYPECAST -> ( [9:28]
        |       |       |           |--TYPE -> TYPE [9:29]
        |       |       |           |   |--LITERAL_INT -> int [9:29]
        |       |       |           |   `--ARRAY_DECLARATOR -> [ [9:32]
        |       |       |           |       `--RBRACK -> ] [9:33]
        |       |       |           |--RPAREN -> ) [9:34]
        |       |       |           `--IDENT -> xorPixel [9:36]
        |       |       |--SEMI -> ; [9:44]
        |       |       `--RCURLY -> } [10:9]
        |       |--METHOD_DEF -> METHOD_DEF [12:9]
        |       |   |--MODIFIERS -> MODIFIERS [12:9]
        |       |   |   `--LITERAL_PROTECTED -> protected [12:9]
        |       |   |--TYPE -> TYPE [12:19]
        |       |   |   `--LITERAL_VOID -> void [12:19]
        |       |   |--IDENT -> xorPixel [12:24]
        |       |   |--LPAREN -> ( [12:32]
        |       |   |--PARAMETERS -> PARAMETERS [12:33]
        |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:33]
        |       |   |       |--MODIFIERS -> MODIFIERS [12:33]
        |       |   |       |--TYPE -> TYPE [12:33]
        |       |   |       |   `--IDENT -> Object [12:33]
        |       |   |       `--IDENT -> pixData [12:40]
        |       |   |--RPAREN -> ) [12:47]
        |       |   `--SLIST -> { [12:49]
        |       |       |--VARIABLE_DEF -> VARIABLE_DEF [13:13]
        |       |       |   |--MODIFIERS -> MODIFIERS [13:13]
        |       |       |   |--TYPE -> TYPE [13:13]
        |       |       |   |   |--LITERAL_INT -> int [13:13]
        |       |       |   |   `--ARRAY_DECLARATOR -> [ [13:16]
        |       |       |   |       `--RBRACK -> ] [13:17]
        |       |       |   |--IDENT -> dstData [13:19]
        |       |       |   `--ASSIGN -> = [13:27]
        |       |       |       `--EXPR -> EXPR [13:29]
        |       |       |           `--TYPECAST -> ( [13:29]
        |       |       |               |--TYPE -> TYPE [13:30]
        |       |       |               |   |--LITERAL_INT -> int [13:30]
        |       |       |               |   `--ARRAY_DECLARATOR -> [ [13:33]
        |       |       |               |       `--RBRACK -> ] [13:34]
        |       |       |               |--RPAREN -> ) [13:35]
        |       |       |               `--IDENT -> pixData [13:37]
        |       |       |--SEMI -> ; [13:44]
        |       |       |--LITERAL_FOR -> for [14:13]
        |       |       |   |--LPAREN -> ( [14:17]
        |       |       |   |--FOR_INIT -> FOR_INIT [14:18]
        |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [14:18]
        |       |       |   |       |--MODIFIERS -> MODIFIERS [14:18]
        |       |       |   |       |--TYPE -> TYPE [14:18]
        |       |       |   |       |   `--LITERAL_INT -> int [14:18]
        |       |       |   |       |--IDENT -> i [14:22]
        |       |       |   |       `--ASSIGN -> = [14:24]
        |       |       |   |           `--EXPR -> EXPR [14:26]
        |       |       |   |               `--NUM_INT -> 0 [14:26]
        |       |       |   |--SEMI -> ; [14:27]
        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [14:31]
        |       |       |   |   `--EXPR -> EXPR [14:31]
        |       |       |   |       `--LT -> < [14:31]
        |       |       |   |           |--IDENT -> i [14:29]
        |       |       |   |           `--DOT -> . [14:40]
        |       |       |   |               |--IDENT -> dstData [14:33]
        |       |       |   |               `--IDENT -> length [14:41]
        |       |       |   |--SEMI -> ; [14:47]
        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [14:50]
        |       |       |   |   `--ELIST -> ELIST [14:50]
        |       |       |   |       `--EXPR -> EXPR [14:50]
        |       |       |   |           `--POST_INC -> ++ [14:50]
        |       |       |   |               `--IDENT -> i [14:49]
        |       |       |   |--RPAREN -> ) [14:52]
        |       |       |   `--SLIST -> { [14:54]
        |       |       |       |--EXPR -> EXPR [15:28]
        |       |       |       |   `--BXOR_ASSIGN -> ^= [15:28]
        |       |       |       |       |--INDEX_OP -> [ [15:24]
        |       |       |       |       |   |--IDENT -> dstData [15:17]
        |       |       |       |       |   |--EXPR -> EXPR [15:25]
        |       |       |       |       |   |   `--IDENT -> i [15:25]
        |       |       |       |       |   `--RBRACK -> ] [15:26]
        |       |       |       |       `--INDEX_OP -> [ [15:38]
        |       |       |       |           |--IDENT -> xorData [15:31]
        |       |       |       |           |--EXPR -> EXPR [15:39]
        |       |       |       |           |   `--IDENT -> i [15:39]
        |       |       |       |           `--RBRACK -> ] [15:40]
        |       |       |       |--SEMI -> ; [15:41]
        |       |       |       `--RCURLY -> } [16:13]
        |       |       `--RCURLY -> } [17:9]
        |       |--METHOD_DEF -> METHOD_DEF [19:9]
        |       |   |--MODIFIERS -> MODIFIERS [19:9]
        |       |   |--TYPE -> TYPE [19:9]
        |       |   |   |--IDENT -> Object [19:9]
        |       |   |   `--ARRAY_DECLARATOR -> [ [19:15]
        |       |   |       `--RBRACK -> ] [19:16]
        |       |   |--IDENT -> getXorData [19:18]
        |       |   |--LPAREN -> ( [19:28]
        |       |   |--PARAMETERS -> PARAMETERS [19:29]
        |       |   |--RPAREN -> ) [19:29]
        |       |   `--SLIST -> { [19:31]
        |       |       |--LITERAL_RETURN -> return [20:13]
        |       |       |   |--EXPR -> EXPR [20:20]
        |       |       |   |   `--LITERAL_NEW -> new [20:20]
        |       |       |   |       |--IDENT -> Object [20:24]
        |       |       |   |       `--ARRAY_DECLARATOR -> [ [20:30]
        |       |       |   |           |--EXPR -> EXPR [20:31]
        |       |       |   |           |   `--NUM_INT -> 5 [20:31]
        |       |       |   |           `--RBRACK -> ] [20:32]
        |       |       |   `--SEMI -> ; [20:33]
        |       |       `--RCURLY -> } [21:9]
        |       |--METHOD_DEF -> METHOD_DEF [23:9]
        |       |   |--MODIFIERS -> MODIFIERS [23:9]
        |       |   |--TYPE -> TYPE [23:9]
        |       |   |   `--LITERAL_VOID -> void [23:9]
        |       |   |--IDENT -> method6 [23:14]
        |       |   |--LPAREN -> ( [23:21]
        |       |   |--PARAMETERS -> PARAMETERS [23:22]
        |       |   |--RPAREN -> ) [23:22]
        |       |   `--SLIST -> { [23:24]
        |       |       |--LITERAL_IF -> if [24:13]
        |       |       |   |--LPAREN -> ( [24:16]
        |       |       |   |--EXPR -> EXPR [26:21]
        |       |       |   |   `--LOR -> || [26:21]
        |       |       |   |       |--LAND -> && [25:21]
        |       |       |   |       |   |--EQUAL -> == [24:37]
        |       |       |   |       |   |   |--DOT -> . [24:29]
        |       |       |   |       |   |   |   |--METHOD_CALL -> ( [24:27]
        |       |       |   |       |   |   |   |   |--IDENT -> getXorData [24:17]
        |       |       |   |       |   |   |   |   |--ELIST -> ELIST [24:28]
        |       |       |   |       |   |   |   |   `--RPAREN -> ) [24:28]
        |       |       |   |       |   |   |   `--IDENT -> length [24:30]
        |       |       |   |       |   |   `--NUM_INT -> 5 [24:40]
        |       |       |   |       |   `--NOT_EQUAL -> != [25:45]
        |       |       |   |       |       |--INDEX_OP -> [ [25:41]
        |       |       |   |       |       |   |--METHOD_CALL -> ( [25:39]
        |       |       |   |       |       |   |   |--DOT -> . [25:28]
        |       |       |   |       |       |   |   |   |--LITERAL_THIS -> this [25:24]
        |       |       |   |       |       |   |   |   `--IDENT -> getXorData [25:29]
        |       |       |   |       |       |   |   |--ELIST -> ELIST [25:40]
        |       |       |   |       |       |   |   `--RPAREN -> ) [25:40]
        |       |       |   |       |       |   |--EXPR -> EXPR [25:42]
        |       |       |   |       |       |   |   `--NUM_INT -> 1 [25:42]
        |       |       |   |       |       |   `--RBRACK -> ] [25:43]
        |       |       |   |       |       `--DOT -> . [25:55]
        |       |       |   |       |           |--IDENT -> IntData [25:48]
        |       |       |   |       |           `--LITERAL_CLASS -> class [25:56]
        |       |       |   |       `--NOT_EQUAL -> != [26:45]
        |       |       |   |           |--INDEX_OP -> [ [26:41]
        |       |       |   |           |   |--METHOD_CALL -> ( [26:39]
        |       |       |   |           |   |   |--DOT -> . [26:28]
        |       |       |   |           |   |   |   |--LITERAL_THIS -> this [26:24]
        |       |       |   |           |   |   |   `--IDENT -> getXorData [26:29]
        |       |       |   |           |   |   |--ELIST -> ELIST [26:40]
        |       |       |   |           |   |   `--RPAREN -> ) [26:40]
        |       |       |   |           |   |--EXPR -> EXPR [26:42]
        |       |       |   |           |   |   `--NUM_INT -> 5 [26:42]
        |       |       |   |           |   `--RBRACK -> ] [26:43]
        |       |       |   |           `--DOT -> . [26:55]
        |       |       |   |               |--IDENT -> IntData [26:48]
        |       |       |   |               `--LITERAL_CLASS -> class [26:56]
        |       |       |   |--RPAREN -> ) [26:61]
        |       |       |   `--SLIST -> { [26:63]
        |       |       |       |--EXPR -> EXPR [27:35]
        |       |       |       |   `--METHOD_CALL -> ( [27:35]
        |       |       |       |       |--DOT -> . [27:27]
        |       |       |       |       |   |--DOT -> . [27:23]
        |       |       |       |       |   |   |--IDENT -> System [27:17]
        |       |       |       |       |   |   `--IDENT -> out [27:24]
        |       |       |       |       |   `--IDENT -> println [27:28]
        |       |       |       |       |--ELIST -> ELIST [27:48]
        |       |       |       |       |   `--EXPR -> EXPR [27:48]
        |       |       |       |       |       `--DOT -> . [27:48]
        |       |       |       |       |           |--METHOD_CALL -> ( [27:46]
        |       |       |       |       |           |   |--IDENT -> getXorData [27:36]
        |       |       |       |       |           |   |--ELIST -> ELIST [27:47]
        |       |       |       |       |           |   `--RPAREN -> ) [27:47]
        |       |       |       |       |           `--IDENT -> length [27:49]
        |       |       |       |       `--RPAREN -> ) [27:55]
        |       |       |       |--SEMI -> ; [27:56]
        |       |       |       `--RCURLY -> } [28:13]
        |       |       `--RCURLY -> } [29:9]
        |       `--RCURLY -> } [31:5]
        `--RCURLY -> } [32:1]
