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