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:14]
|   |   |--DOT -> . [3:11]
|   |   |   |--IDENT -> java [3:7]
|   |   |   `--IDENT -> io [3:12]
|   |   `--IDENT -> Serializable [3:15]
|   `--SEMI -> ; [3:27]
|--CLASS_DEF -> CLASS_DEF [5:0]
|   |--MODIFIERS -> MODIFIERS [5:0]
|   |   `--LITERAL_PUBLIC -> public [5:0]
|   |--LITERAL_CLASS -> class [5:7]
|   |--IDENT -> InputAntlr4AstRegressionForLoops [5:13]
|   `--OBJBLOCK -> OBJBLOCK [5:46]
|       |--LCURLY -> { [5:46]
|       |--VARIABLE_DEF -> VARIABLE_DEF [6:3]
|       |   |--MODIFIERS -> MODIFIERS [6:3]
|       |   |--TYPE -> TYPE [6:3]
|       |   |   `--LITERAL_INT -> int [6:3]
|       |   |--IDENT -> k [6:7]
|       |   `--SEMI -> ; [6:8]
|       |--METHOD_DEF -> METHOD_DEF [7:4]
|       |   |--MODIFIERS -> MODIFIERS [7:4]
|       |   |--TYPE -> TYPE [7:4]
|       |   |   `--LITERAL_VOID -> void [7:4]
|       |   |--IDENT -> method1 [7:9]
|       |   |--LPAREN -> ( [7:16]
|       |   |--PARAMETERS -> PARAMETERS [7:17]
|       |   |--RPAREN -> ) [7:17]
|       |   `--SLIST -> { [8:4]
|       |       |--LITERAL_FOR -> for [10:8]
|       |       |   |--LPAREN -> ( [10:12]
|       |       |   |--FOR_INIT -> FOR_INIT [10:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [10:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [10:13]
|       |       |   |       |--TYPE -> TYPE [10:13]
|       |       |   |       |   `--LITERAL_INT -> int [10:13]
|       |       |   |       |--IDENT -> i [10:17]
|       |       |   |       `--ASSIGN -> = [10:19]
|       |       |   |           `--EXPR -> EXPR [10:21]
|       |       |   |               `--NUM_INT -> 0 [10:21]
|       |       |   |--SEMI -> ; [10:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [10:26]
|       |       |   |   `--EXPR -> EXPR [10:26]
|       |       |   |       `--LT -> < [10:26]
|       |       |   |           |--IDENT -> i [10:24]
|       |       |   |           `--NUM_INT -> 1 [10:28]
|       |       |   |--SEMI -> ; [10:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [10:32]
|       |       |   |   `--ELIST -> ELIST [10:32]
|       |       |   |       `--EXPR -> EXPR [10:32]
|       |       |   |           `--POST_INC -> ++ [10:32]
|       |       |   |               `--IDENT -> i [10:31]
|       |       |   |--RPAREN -> ) [10:34]
|       |       |   `--SLIST -> { [10:36]
|       |       |       |--EXPR -> EXPR [11:13]
|       |       |       |   `--POST_INC -> ++ [11:13]
|       |       |       |       `--IDENT -> i [11:12]
|       |       |       |--SEMI -> ; [11:15]
|       |       |       `--RCURLY -> } [12:8]
|       |       |--LITERAL_FOR -> for [13:8]
|       |       |   |--LPAREN -> ( [13:12]
|       |       |   |--FOR_INIT -> FOR_INIT [13:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [13:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [13:13]
|       |       |   |       |--TYPE -> TYPE [13:13]
|       |       |   |       |   `--LITERAL_INT -> int [13:13]
|       |       |   |       |--IDENT -> i [13:17]
|       |       |   |       `--ASSIGN -> = [13:19]
|       |       |   |           `--EXPR -> EXPR [13:21]
|       |       |   |               `--NUM_INT -> 0 [13:21]
|       |       |   |--SEMI -> ; [13:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [13:26]
|       |       |   |   `--EXPR -> EXPR [13:26]
|       |       |   |       `--LT -> < [13:26]
|       |       |   |           |--IDENT -> i [13:24]
|       |       |   |           `--NUM_INT -> 1 [13:28]
|       |       |   |--SEMI -> ; [13:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [13:32]
|       |       |   |   `--ELIST -> ELIST [13:32]
|       |       |   |       `--EXPR -> EXPR [13:32]
|       |       |   |           `--POST_INC -> ++ [13:32]
|       |       |   |               `--IDENT -> i [13:31]
|       |       |   |--RPAREN -> ) [13:34]
|       |       |   `--SLIST -> { [13:36]
|       |       |       |--EXPR -> EXPR [14:14]
|       |       |       |   `--ASSIGN -> = [14:14]
|       |       |       |       |--IDENT -> i [14:12]
|       |       |       |       `--PLUS -> + [14:18]
|       |       |       |           |--IDENT -> i [14:16]
|       |       |       |           `--NUM_INT -> 1 [14:20]
|       |       |       |--SEMI -> ; [14:21]
|       |       |       `--RCURLY -> } [15:8]
|       |       |--LITERAL_FOR -> for [16:8]
|       |       |   |--LPAREN -> ( [16:12]
|       |       |   |--FOR_INIT -> FOR_INIT [16:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [16:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [16:13]
|       |       |   |       |--TYPE -> TYPE [16:13]
|       |       |   |       |   `--LITERAL_INT -> int [16:13]
|       |       |   |       |--IDENT -> i [16:17]
|       |       |   |       `--ASSIGN -> = [16:19]
|       |       |   |           `--EXPR -> EXPR [16:21]
|       |       |   |               `--NUM_INT -> 0 [16:21]
|       |       |   |--SEMI -> ; [16:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [16:26]
|       |       |   |   `--EXPR -> EXPR [16:26]
|       |       |   |       `--LT -> < [16:26]
|       |       |   |           |--IDENT -> i [16:24]
|       |       |   |           `--NUM_INT -> 1 [16:28]
|       |       |   |--SEMI -> ; [16:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [16:32]
|       |       |   |   `--ELIST -> ELIST [16:32]
|       |       |   |       `--EXPR -> EXPR [16:32]
|       |       |   |           `--POST_INC -> ++ [16:32]
|       |       |   |               `--IDENT -> i [16:31]
|       |       |   |--RPAREN -> ) [16:34]
|       |       |   `--SLIST -> { [16:36]
|       |       |       |--LITERAL_FOR -> for [17:12]
|       |       |       |   |--LPAREN -> ( [17:16]
|       |       |       |   |--FOR_INIT -> FOR_INIT [17:17]
|       |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [17:17]
|       |       |       |   |       |--MODIFIERS -> MODIFIERS [17:17]
|       |       |       |   |       |--TYPE -> TYPE [17:17]
|       |       |       |   |       |   `--LITERAL_INT -> int [17:17]
|       |       |       |   |       |--IDENT -> j [17:21]
|       |       |       |   |       `--ASSIGN -> = [17:23]
|       |       |       |   |           `--EXPR -> EXPR [17:25]
|       |       |       |   |               `--NUM_INT -> 0 [17:25]
|       |       |       |   |--SEMI -> ; [17:26]
|       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [17:30]
|       |       |       |   |   `--EXPR -> EXPR [17:30]
|       |       |       |   |       `--LT -> < [17:30]
|       |       |       |   |           |--IDENT -> j [17:28]
|       |       |       |   |           `--NUM_INT -> 1 [17:32]
|       |       |       |   |--SEMI -> ; [17:33]
|       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [17:36]
|       |       |       |   |   `--ELIST -> ELIST [17:36]
|       |       |       |   |       `--EXPR -> EXPR [17:36]
|       |       |       |   |           `--POST_INC -> ++ [17:36]
|       |       |       |   |               `--IDENT -> i [17:35]
|       |       |       |   |--RPAREN -> ) [17:38]
|       |       |       |   `--SLIST -> { [17:40]
|       |       |       |       |--EXPR -> EXPR [18:16]
|       |       |       |       |   `--DEC -> -- [18:16]
|       |       |       |       |       `--IDENT -> i [18:18]
|       |       |       |       |--SEMI -> ; [18:19]
|       |       |       |       `--RCURLY -> } [19:12]
|       |       |       `--RCURLY -> } [20:8]
|       |       |--LITERAL_FOR -> for [21:8]
|       |       |   |--LPAREN -> ( [21:12]
|       |       |   |--FOR_INIT -> FOR_INIT [21:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [21:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [21:13]
|       |       |   |   |   |--TYPE -> TYPE [21:13]
|       |       |   |   |   |   `--LITERAL_INT -> int [21:13]
|       |       |   |   |   |--IDENT -> i [21:17]
|       |       |   |   |   `--ASSIGN -> = [21:19]
|       |       |   |   |       `--EXPR -> EXPR [21:21]
|       |       |   |   |           `--NUM_INT -> 0 [21:21]
|       |       |   |   |--COMMA -> , [21:22]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [21:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [21:13]
|       |       |   |       |--TYPE -> TYPE [21:13]
|       |       |   |       |   `--LITERAL_INT -> int [21:13]
|       |       |   |       |--IDENT -> j [21:24]
|       |       |   |       `--ASSIGN -> = [21:26]
|       |       |   |           `--EXPR -> EXPR [21:28]
|       |       |   |               `--NUM_INT -> 0 [21:28]
|       |       |   |--SEMI -> ; [21:29]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [21:33]
|       |       |   |   `--EXPR -> EXPR [21:33]
|       |       |   |       `--LT -> < [21:33]
|       |       |   |           |--IDENT -> i [21:31]
|       |       |   |           `--NUM_INT -> 1 [21:35]
|       |       |   |--SEMI -> ; [21:36]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [21:39]
|       |       |   |   `--ELIST -> ELIST [21:39]
|       |       |   |       `--EXPR -> EXPR [21:39]
|       |       |   |           `--POST_INC -> ++ [21:39]
|       |       |   |               `--IDENT -> i [21:38]
|       |       |   |--RPAREN -> ) [21:41]
|       |       |   `--SLIST -> { [21:43]
|       |       |       |--EXPR -> EXPR [22:13]
|       |       |       |   `--POST_INC -> ++ [22:13]
|       |       |       |       `--IDENT -> j [22:12]
|       |       |       |--SEMI -> ; [22:15]
|       |       |       `--RCURLY -> } [23:8]
|       |       |--LITERAL_FOR -> for [26:8]
|       |       |   |--LPAREN -> ( [26:12]
|       |       |   |--FOR_INIT -> FOR_INIT [26:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [26:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [26:13]
|       |       |   |       |--TYPE -> TYPE [26:13]
|       |       |   |       |   `--LITERAL_INT -> int [26:13]
|       |       |   |       |--IDENT -> i [26:17]
|       |       |   |       `--ASSIGN -> = [26:19]
|       |       |   |           `--EXPR -> EXPR [26:21]
|       |       |   |               `--NUM_INT -> 0 [26:21]
|       |       |   |--SEMI -> ; [26:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [26:26]
|       |       |   |   `--EXPR -> EXPR [26:26]
|       |       |   |       `--LT -> < [26:26]
|       |       |   |           |--IDENT -> i [26:24]
|       |       |   |           `--NUM_INT -> 1 [26:28]
|       |       |   |--SEMI -> ; [26:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [26:32]
|       |       |   |   `--ELIST -> ELIST [26:32]
|       |       |   |       `--EXPR -> EXPR [26:32]
|       |       |   |           `--POST_INC -> ++ [26:32]
|       |       |   |               `--IDENT -> i [26:31]
|       |       |   |--RPAREN -> ) [26:34]
|       |       |   `--SLIST -> { [26:36]
|       |       |       `--RCURLY -> } [27:8]
|       |       |--LITERAL_FOR -> for [28:8]
|       |       |   |--LPAREN -> ( [28:12]
|       |       |   |--FOR_INIT -> FOR_INIT [28:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [28:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [28:13]
|       |       |   |       |--TYPE -> TYPE [28:13]
|       |       |   |       |   `--LITERAL_INT -> int [28:13]
|       |       |   |       |--IDENT -> i [28:17]
|       |       |   |       `--ASSIGN -> = [28:19]
|       |       |   |           `--EXPR -> EXPR [28:21]
|       |       |   |               `--NUM_INT -> 0 [28:21]
|       |       |   |--SEMI -> ; [28:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [28:26]
|       |       |   |   `--EXPR -> EXPR [28:26]
|       |       |   |       `--LT -> < [28:26]
|       |       |   |           |--IDENT -> i [28:24]
|       |       |   |           `--NUM_INT -> 1 [28:28]
|       |       |   |--SEMI -> ; [28:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [28:32]
|       |       |   |   `--ELIST -> ELIST [28:32]
|       |       |   |       `--EXPR -> EXPR [28:32]
|       |       |   |           `--POST_INC -> ++ [28:32]
|       |       |   |               `--IDENT -> i [28:31]
|       |       |   |--RPAREN -> ) [28:34]
|       |       |   `--SLIST -> { [28:36]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [29:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [29:12]
|       |       |       |   |--TYPE -> TYPE [29:12]
|       |       |       |   |   `--LITERAL_INT -> int [29:12]
|       |       |       |   |--IDENT -> x [29:16]
|       |       |       |   `--ASSIGN -> = [29:18]
|       |       |       |       `--EXPR -> EXPR [29:20]
|       |       |       |           `--IDENT -> i [29:20]
|       |       |       |--SEMI -> ; [29:21]
|       |       |       `--RCURLY -> } [30:8]
|       |       |--LITERAL_FOR -> for [31:8]
|       |       |   |--LPAREN -> ( [31:12]
|       |       |   |--FOR_INIT -> FOR_INIT [31:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [31:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [31:13]
|       |       |   |       |--TYPE -> TYPE [31:13]
|       |       |   |       |   `--LITERAL_INT -> int [31:13]
|       |       |   |       |--IDENT -> i [31:17]
|       |       |   |       `--ASSIGN -> = [31:19]
|       |       |   |           `--EXPR -> EXPR [31:21]
|       |       |   |               `--NUM_INT -> 0 [31:21]
|       |       |   |--SEMI -> ; [31:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [31:26]
|       |       |   |   `--EXPR -> EXPR [31:26]
|       |       |   |       `--LT -> < [31:26]
|       |       |   |           |--IDENT -> i [31:24]
|       |       |   |           `--NUM_INT -> 1 [31:28]
|       |       |   |--SEMI -> ; [31:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [31:32]
|       |       |   |   `--ELIST -> ELIST [31:32]
|       |       |   |       `--EXPR -> EXPR [31:32]
|       |       |   |           `--POST_INC -> ++ [31:32]
|       |       |   |               `--IDENT -> i [31:31]
|       |       |   |--RPAREN -> ) [31:34]
|       |       |   `--SLIST -> { [31:36]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [32:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [32:12]
|       |       |       |   |--TYPE -> TYPE [32:12]
|       |       |       |   |   `--IDENT -> Serializable [32:12]
|       |       |       |   |--IDENT -> s [32:25]
|       |       |       |   `--ASSIGN -> = [32:27]
|       |       |       |       `--EXPR -> EXPR [32:29]
|       |       |       |           `--LITERAL_NEW -> new [32:29]
|       |       |       |               |--IDENT -> Serializable [32:33]
|       |       |       |               |--LPAREN -> ( [32:45]
|       |       |       |               |--ELIST -> ELIST [32:46]
|       |       |       |               |--RPAREN -> ) [32:46]
|       |       |       |               `--OBJBLOCK -> OBJBLOCK [32:48]
|       |       |       |                   |--LCURLY -> { [32:48]
|       |       |       |                   |--VARIABLE_DEF -> VARIABLE_DEF [33:16]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [33:16]
|       |       |       |                   |   |--TYPE -> TYPE [33:16]
|       |       |       |                   |   |   `--LITERAL_INT -> int [33:16]
|       |       |       |                   |   |--IDENT -> i [33:20]
|       |       |       |                   |   |--ASSIGN -> = [33:22]
|       |       |       |                   |   |   `--EXPR -> EXPR [33:24]
|       |       |       |                   |   |       `--NUM_INT -> 3 [33:24]
|       |       |       |                   |   `--SEMI -> ; [33:25]
|       |       |       |                   |--METHOD_DEF -> METHOD_DEF [34:16]
|       |       |       |                   |   |--MODIFIERS -> MODIFIERS [34:16]
|       |       |       |                   |   |--TYPE -> TYPE [34:16]
|       |       |       |                   |   |   `--LITERAL_VOID -> void [34:16]
|       |       |       |                   |   |--IDENT -> a [34:21]
|       |       |       |                   |   |--LPAREN -> ( [34:22]
|       |       |       |                   |   |--PARAMETERS -> PARAMETERS [34:23]
|       |       |       |                   |   |--RPAREN -> ) [34:23]
|       |       |       |                   |   `--SLIST -> { [34:25]
|       |       |       |                   |       |--EXPR -> EXPR [35:43]
|       |       |       |                   |       |   `--METHOD_CALL -> ( [35:43]
|       |       |       |                   |       |       |--DOT -> . [35:26]
|       |       |       |                   |       |       |   |--IDENT -> System [35:20]
|       |       |       |                   |       |       |   `--IDENT -> identityHashCode [35:27]
|       |       |       |                   |       |       |--ELIST -> ELIST [35:45]
|       |       |       |                   |       |       |   `--EXPR -> EXPR [35:45]
|       |       |       |                   |       |       |       `--POST_INC -> ++ [35:45]
|       |       |       |                   |       |       |           `--IDENT -> i [35:44]
|       |       |       |                   |       |       `--RPAREN -> ) [35:47]
|       |       |       |                   |       |--SEMI -> ; [35:48]
|       |       |       |                   |       `--RCURLY -> } [36:16]
|       |       |       |                   `--RCURLY -> } [37:12]
|       |       |       |--SEMI -> ; [37:13]
|       |       |       `--RCURLY -> } [38:8]
|       |       |--LITERAL_FOR -> for [39:8]
|       |       |   |--LPAREN -> ( [39:12]
|       |       |   |--FOR_INIT -> FOR_INIT [39:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [39:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [39:13]
|       |       |   |       |--TYPE -> TYPE [39:13]
|       |       |   |       |   `--LITERAL_INT -> int [39:13]
|       |       |   |       |--IDENT -> k [39:17]
|       |       |   |       `--ASSIGN -> = [39:19]
|       |       |   |           `--EXPR -> EXPR [39:21]
|       |       |   |               `--NUM_INT -> 0 [39:21]
|       |       |   |--SEMI -> ; [39:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [39:26]
|       |       |   |   `--EXPR -> EXPR [39:26]
|       |       |   |       `--LT -> < [39:26]
|       |       |   |           |--IDENT -> k [39:24]
|       |       |   |           `--NUM_INT -> 1 [39:28]
|       |       |   |--SEMI -> ; [39:29]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [39:32]
|       |       |   |   `--ELIST -> ELIST [39:32]
|       |       |   |       `--EXPR -> EXPR [39:32]
|       |       |   |           `--POST_INC -> ++ [39:32]
|       |       |   |               `--IDENT -> k [39:31]
|       |       |   |--RPAREN -> ) [39:34]
|       |       |   `--SLIST -> { [39:36]
|       |       |       |--EXPR -> EXPR [40:18]
|       |       |       |   `--POST_INC -> ++ [40:18]
|       |       |       |       `--DOT -> . [40:16]
|       |       |       |           |--LITERAL_THIS -> this [40:12]
|       |       |       |           `--IDENT -> k [40:17]
|       |       |       |--SEMI -> ; [40:20]
|       |       |       `--RCURLY -> } [41:8]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
|       |       |   |--MODIFIERS -> MODIFIERS [43:8]
|       |       |   |--TYPE -> TYPE [43:8]
|       |       |   |   |--IDENT -> String [43:8]
|       |       |   |   `--ARRAY_DECLARATOR -> [ [43:14]
|       |       |   |       `--RBRACK -> ] [43:15]
|       |       |   |--IDENT -> sa [43:17]
|       |       |   `--ASSIGN -> = [43:20]
|       |       |       `--ARRAY_INIT -> { [43:22]
|       |       |           |--EXPR -> EXPR [43:23]
|       |       |           |   `--STRING_LITERAL -> "a" [43:23]
|       |       |           |--COMMA -> , [43:26]
|       |       |           |--EXPR -> EXPR [43:28]
|       |       |           |   `--STRING_LITERAL -> "b" [43:28]
|       |       |           `--RCURLY -> } [43:31]
|       |       |--SEMI -> ; [43:32]
|       |       |--LITERAL_FOR -> for [44:8]
|       |       |   |--LPAREN -> ( [44:11]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [44:12]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [44:12]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [44:12]
|       |       |   |   |   |--TYPE -> TYPE [44:12]
|       |       |   |   |   |   `--IDENT -> String [44:12]
|       |       |   |   |   `--IDENT -> s [44:19]
|       |       |   |   |--COLON -> : [44:20]
|       |       |   |   `--EXPR -> EXPR [44:21]
|       |       |   |       `--IDENT -> sa [44:21]
|       |       |   |--RPAREN -> ) [44:23]
|       |       |   `--SLIST -> { [44:25]
|       |       |       `--RCURLY -> } [44:26]
|       |       |--LITERAL_FOR -> for [45:8]
|       |       |   |--LPAREN -> ( [45:11]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [45:12]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [45:12]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [45:12]
|       |       |   |   |   |--TYPE -> TYPE [45:12]
|       |       |   |   |   |   `--IDENT -> String [45:12]
|       |       |   |   |   `--IDENT -> s [45:19]
|       |       |   |   |--COLON -> : [45:20]
|       |       |   |   `--EXPR -> EXPR [45:21]
|       |       |   |       `--IDENT -> sa [45:21]
|       |       |   |--RPAREN -> ) [45:23]
|       |       |   `--SLIST -> { [45:25]
|       |       |       |--EXPR -> EXPR [46:14]
|       |       |       |   `--ASSIGN -> = [46:14]
|       |       |       |       |--IDENT -> s [46:12]
|       |       |       |       `--STRING_LITERAL -> "new string" [46:16]
|       |       |       |--SEMI -> ; [46:28]
|       |       |       `--RCURLY -> } [47:8]
|       |       |--LITERAL_FOR -> for [48:8]
|       |       |   |--LPAREN -> ( [48:11]
|       |       |   |--FOR_INIT -> FOR_INIT [48:12]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [48:12]
|       |       |   |       |--MODIFIERS -> MODIFIERS [48:12]
|       |       |   |       |--TYPE -> TYPE [48:12]
|       |       |   |       |   `--LITERAL_INT -> int [48:12]
|       |       |   |       |--IDENT -> i [48:16]
|       |       |   |       `--ASSIGN -> = [48:17]
|       |       |   |           `--EXPR -> EXPR [48:18]
|       |       |   |               `--NUM_INT -> 0 [48:18]
|       |       |   |--SEMI -> ; [48:19]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [48:22]
|       |       |   |   `--EXPR -> EXPR [48:22]
|       |       |   |       `--LT -> < [48:22]
|       |       |   |           |--IDENT -> i [48:20]
|       |       |   |           `--NUM_INT -> 10 [48:24]
|       |       |   |--SEMI -> ; [48:26]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [48:27]
|       |       |   |--RPAREN -> ) [48:27]
|       |       |   `--SLIST -> { [48:29]
|       |       |       |--EXPR -> EXPR [49:13]
|       |       |       |   `--POST_INC -> ++ [49:13]
|       |       |       |       `--IDENT -> i [49:12]
|       |       |       |--SEMI -> ; [49:15]
|       |       |       `--RCURLY -> } [50:8]
|       |       |--LITERAL_FOR -> for [51:8]
|       |       |   |--LPAREN -> ( [51:12]
|       |       |   |--FOR_INIT -> FOR_INIT [51:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [51:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [51:13]
|       |       |   |   |   |--TYPE -> TYPE [51:13]
|       |       |   |   |   |   `--LITERAL_INT -> int [51:13]
|       |       |   |   |   |--IDENT -> i [51:17]
|       |       |   |   |   `--ASSIGN -> = [51:19]
|       |       |   |   |       `--EXPR -> EXPR [51:21]
|       |       |   |   |           `--NUM_INT -> 0 [51:21]
|       |       |   |   |--COMMA -> , [51:22]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [51:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [51:13]
|       |       |   |   |   |--TYPE -> TYPE [51:13]
|       |       |   |   |   |   `--LITERAL_INT -> int [51:13]
|       |       |   |   |   |--IDENT -> l [51:24]
|       |       |   |   |   `--ASSIGN -> = [51:26]
|       |       |   |   |       `--EXPR -> EXPR [51:28]
|       |       |   |   |           `--NUM_INT -> 0 [51:28]
|       |       |   |   |--COMMA -> , [51:29]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [51:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [51:13]
|       |       |   |       |--TYPE -> TYPE [51:13]
|       |       |   |       |   `--LITERAL_INT -> int [51:13]
|       |       |   |       |--IDENT -> m [51:30]
|       |       |   |       `--ASSIGN -> = [51:31]
|       |       |   |           `--EXPR -> EXPR [51:32]
|       |       |   |               `--NUM_INT -> 0 [51:32]
|       |       |   |--SEMI -> ; [51:33]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [51:37]
|       |       |   |   `--EXPR -> EXPR [51:37]
|       |       |   |       `--LT -> < [51:37]
|       |       |   |           |--IDENT -> l [51:35]
|       |       |   |           `--NUM_INT -> 10 [51:39]
|       |       |   |--SEMI -> ; [51:41]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [51:44]
|       |       |   |   `--ELIST -> ELIST [51:44]
|       |       |   |       |--EXPR -> EXPR [51:44]
|       |       |   |       |   `--POST_INC -> ++ [51:44]
|       |       |   |       |       `--IDENT -> i [51:43]
|       |       |   |       |--COMMA -> , [51:46]
|       |       |   |       `--EXPR -> EXPR [51:48]
|       |       |   |           `--ASSIGN -> = [51:48]
|       |       |   |               |--IDENT -> m [51:47]
|       |       |   |               `--PLUS -> + [51:50]
|       |       |   |                   |--IDENT -> m [51:49]
|       |       |   |                   `--NUM_INT -> 2 [51:51]
|       |       |   |--RPAREN -> ) [51:52]
|       |       |   `--SLIST -> { [51:54]
|       |       |       |--EXPR -> EXPR [52:13]
|       |       |       |   `--POST_INC -> ++ [52:13]
|       |       |       |       `--IDENT -> l [52:12]
|       |       |       |--SEMI -> ; [52:15]
|       |       |       |--EXPR -> EXPR [53:13]
|       |       |       |   `--POST_INC -> ++ [53:13]
|       |       |       |       `--IDENT -> m [53:12]
|       |       |       |--SEMI -> ; [53:15]
|       |       |       `--RCURLY -> } [54:8]
|       |       |--LITERAL_FOR -> for [55:8]
|       |       |   |--LPAREN -> ( [55:12]
|       |       |   |--FOR_INIT -> FOR_INIT [55:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [55:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [55:13]
|       |       |   |       |--TYPE -> TYPE [55:13]
|       |       |   |       |   `--LITERAL_INT -> int [55:13]
|       |       |   |       |--IDENT -> i [55:17]
|       |       |   |       `--ASSIGN -> = [55:19]
|       |       |   |           `--EXPR -> EXPR [55:21]
|       |       |   |               `--NUM_INT -> 0 [55:21]
|       |       |   |--SEMI -> ; [55:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [55:26]
|       |       |   |   `--EXPR -> EXPR [55:26]
|       |       |   |       `--LT -> < [55:26]
|       |       |   |           |--IDENT -> i [55:24]
|       |       |   |           `--NUM_INT -> 10 [55:28]
|       |       |   |--SEMI -> ; [55:30]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [55:32]
|       |       |   |--RPAREN -> ) [55:32]
|       |       |   `--SLIST -> { [55:34]
|       |       |       |--EXPR -> EXPR [56:14]
|       |       |       |   `--ASSIGN -> = [56:14]
|       |       |       |       |--IDENT -> i [56:12]
|       |       |       |       `--NUM_INT -> 11 [56:16]
|       |       |       |--SEMI -> ; [56:18]
|       |       |       `--RCURLY -> } [57:8]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [58:8]
|       |       |   |--MODIFIERS -> MODIFIERS [58:8]
|       |       |   |--TYPE -> TYPE [58:8]
|       |       |   |   `--LITERAL_INT -> int [58:8]
|       |       |   |--IDENT -> w [58:12]
|       |       |   `--ASSIGN -> = [58:13]
|       |       |       `--EXPR -> EXPR [58:14]
|       |       |           `--NUM_INT -> 0 [58:14]
|       |       |--SEMI -> ; [58:15]
|       |       |--LITERAL_FOR -> for [59:8]
|       |       |   |--LPAREN -> ( [59:12]
|       |       |   |--FOR_INIT -> FOR_INIT [59:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [59:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [59:13]
|       |       |   |       |--TYPE -> TYPE [59:13]
|       |       |   |       |   `--LITERAL_INT -> int [59:13]
|       |       |   |       |--IDENT -> i [59:17]
|       |       |   |       `--ASSIGN -> = [59:18]
|       |       |   |           `--EXPR -> EXPR [59:19]
|       |       |   |               `--NUM_INT -> 0 [59:19]
|       |       |   |--SEMI -> ; [59:20]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [59:22]
|       |       |   |   `--EXPR -> EXPR [59:22]
|       |       |   |       `--LT -> < [59:22]
|       |       |   |           |--IDENT -> i [59:21]
|       |       |   |           `--NUM_INT -> 10 [59:23]
|       |       |   |--SEMI -> ; [59:25]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [59:48]
|       |       |   |   `--ELIST -> ELIST [59:48]
|       |       |   |       |--EXPR -> EXPR [59:48]
|       |       |   |       |   `--METHOD_CALL -> ( [59:48]
|       |       |   |       |       |--DOT -> . [59:40]
|       |       |   |       |       |   |--DOT -> . [59:35]
|       |       |   |       |       |   |   |--DOT -> . [59:31]
|       |       |   |       |       |   |   |   |--IDENT -> java [59:27]
|       |       |   |       |       |   |   |   `--IDENT -> sql [59:32]
|       |       |   |       |       |   |   `--IDENT -> Date [59:36]
|       |       |   |       |       |   `--IDENT -> valueOf [59:41]
|       |       |   |       |       |--ELIST -> ELIST [59:49]
|       |       |   |       |       |   `--EXPR -> EXPR [59:49]
|       |       |   |       |       |       `--STRING_LITERAL -> "" [59:49]
|       |       |   |       |       `--RPAREN -> ) [59:51]
|       |       |   |       |--COMMA -> , [59:52]
|       |       |   |       |--EXPR -> EXPR [59:59]
|       |       |   |       |   `--POST_INC -> ++ [59:59]
|       |       |   |       |       `--DOT -> . [59:57]
|       |       |   |       |           |--LITERAL_THIS -> this [59:53]
|       |       |   |       |           `--IDENT -> i [59:58]
|       |       |   |       |--COMMA -> , [59:61]
|       |       |   |       `--EXPR -> EXPR [59:63]
|       |       |   |           `--POST_INC -> ++ [59:63]
|       |       |   |               `--IDENT -> w [59:62]
|       |       |   |--RPAREN -> ) [59:65]
|       |       |   `--SLIST -> { [59:67]
|       |       |       |--EXPR -> EXPR [60:13]
|       |       |       |   `--POST_INC -> ++ [60:13]
|       |       |       |       `--IDENT -> i [60:12]
|       |       |       |--SEMI -> ; [60:15]
|       |       |       |--EXPR -> EXPR [61:13]
|       |       |       |   `--POST_INC -> ++ [61:13]
|       |       |       |       `--IDENT -> w [61:12]
|       |       |       |--SEMI -> ; [61:15]
|       |       |       `--RCURLY -> } [62:8]
|       |       |--LITERAL_FOR -> for [63:8]
|       |       |   |--LPAREN -> ( [63:12]
|       |       |   |--FOR_INIT -> FOR_INIT [63:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [63:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [63:13]
|       |       |   |   |   |--TYPE -> TYPE [63:13]
|       |       |   |   |   |   `--LITERAL_INT -> int [63:13]
|       |       |   |   |   |--IDENT -> i [63:17]
|       |       |   |   |   `--ASSIGN -> = [63:18]
|       |       |   |   |       `--EXPR -> EXPR [63:19]
|       |       |   |   |           `--NUM_INT -> 0 [63:19]
|       |       |   |   |--COMMA -> , [63:20]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [63:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [63:13]
|       |       |   |       |--TYPE -> TYPE [63:13]
|       |       |   |       |   `--LITERAL_INT -> int [63:13]
|       |       |   |       |--IDENT -> k [63:21]
|       |       |   |       `--ASSIGN -> = [63:22]
|       |       |   |           `--EXPR -> EXPR [63:23]
|       |       |   |               `--NUM_INT -> 0 [63:23]
|       |       |   |--SEMI -> ; [63:24]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [63:31]
|       |       |   |   `--EXPR -> EXPR [63:31]
|       |       |   |       `--LAND -> && [63:31]
|       |       |   |           |--LT -> < [63:27]
|       |       |   |           |   |--IDENT -> i [63:26]
|       |       |   |           |   `--NUM_INT -> 10 [63:28]
|       |       |   |           `--LT -> < [63:36]
|       |       |   |               |--IDENT -> k [63:34]
|       |       |   |               `--NUM_INT -> 10 [63:38]
|       |       |   |--SEMI -> ; [63:40]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [63:42]
|       |       |   |   `--ELIST -> ELIST [63:42]
|       |       |   |       |--EXPR -> EXPR [63:42]
|       |       |   |       |   `--INC -> ++ [63:42]
|       |       |   |       |       `--IDENT -> i [63:44]
|       |       |   |       |--COMMA -> , [63:45]
|       |       |   |       `--EXPR -> EXPR [63:46]
|       |       |   |           `--INC -> ++ [63:46]
|       |       |   |               `--IDENT -> k [63:48]
|       |       |   |--RPAREN -> ) [63:49]
|       |       |   `--SLIST -> { [63:51]
|       |       |       |--EXPR -> EXPR [64:14]
|       |       |       |   `--ASSIGN -> = [64:14]
|       |       |       |       |--IDENT -> i [64:12]
|       |       |       |       `--PLUS -> + [64:18]
|       |       |       |           |--IDENT -> i [64:16]
|       |       |       |           `--NUM_INT -> 3 [64:20]
|       |       |       |--SEMI -> ; [64:21]
|       |       |       |--EXPR -> EXPR [65:14]
|       |       |       |   `--ASSIGN -> = [65:14]
|       |       |       |       |--IDENT -> k [65:12]
|       |       |       |       `--PLUS -> + [65:18]
|       |       |       |           |--IDENT -> k [65:16]
|       |       |       |           `--NUM_INT -> 4 [65:20]
|       |       |       |--SEMI -> ; [65:21]
|       |       |       `--RCURLY -> } [66:8]
|       |       |--LITERAL_FOR -> for [67:8]
|       |       |   |--LPAREN -> ( [67:12]
|       |       |   |--FOR_INIT -> FOR_INIT [67:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [67:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [67:13]
|       |       |   |   |   |--TYPE -> TYPE [67:13]
|       |       |   |   |   |   `--LITERAL_INT -> int [67:13]
|       |       |   |   |   |--IDENT -> i [67:17]
|       |       |   |   |   `--ASSIGN -> = [67:19]
|       |       |   |   |       `--EXPR -> EXPR [67:21]
|       |       |   |   |           `--NUM_INT -> 0 [67:21]
|       |       |   |   |--COMMA -> , [67:22]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [67:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [67:13]
|       |       |   |       |--TYPE -> TYPE [67:13]
|       |       |   |       |   `--LITERAL_INT -> int [67:13]
|       |       |   |       |--IDENT -> j [67:23]
|       |       |   |       `--ASSIGN -> = [67:25]
|       |       |   |           `--EXPR -> EXPR [67:27]
|       |       |   |               `--NUM_INT -> 0 [67:27]
|       |       |   |--SEMI -> ; [67:29]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [67:33]
|       |       |   |   `--EXPR -> EXPR [67:33]
|       |       |   |       `--LT -> < [67:33]
|       |       |   |           |--IDENT -> i [67:31]
|       |       |   |           `--NUM_INT -> 10 [67:34]
|       |       |   |--SEMI -> ; [67:36]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [67:39]
|       |       |   |   `--ELIST -> ELIST [67:39]
|       |       |   |       `--EXPR -> EXPR [67:39]
|       |       |   |           `--POST_INC -> ++ [67:39]
|       |       |   |               `--IDENT -> i [67:38]
|       |       |   |--RPAREN -> ) [67:41]
|       |       |   `--SLIST -> { [67:43]
|       |       |       |--EXPR -> EXPR [68:13]
|       |       |       |   `--POST_INC -> ++ [68:13]
|       |       |       |       `--IDENT -> j [68:12]
|       |       |       |--SEMI -> ; [68:15]
|       |       |       `--RCURLY -> } [69:8]
|       |       |--LITERAL_FOR -> for [71:8]
|       |       |   |--LPAREN -> ( [71:12]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [71:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [71:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [71:13]
|       |       |   |   |   |--TYPE -> TYPE [71:13]
|       |       |   |   |   |   `--IDENT -> String [71:13]
|       |       |   |   |   `--IDENT -> v [71:20]
|       |       |   |   |--COLON -> : [71:22]
|       |       |   |   `--EXPR -> EXPR [71:24]
|       |       |   |       `--IDENT -> sa [71:24]
|       |       |   |--RPAREN -> ) [71:26]
|       |       |   `--SLIST -> { [71:28]
|       |       |       |--EXPR -> EXPR [72:12]
|       |       |       |   `--LITERAL_NEW -> new [72:12]
|       |       |       |       |--IDENT -> NestedClass [72:16]
|       |       |       |       |--LPAREN -> ( [72:27]
|       |       |       |       |--ELIST -> ELIST [72:28]
|       |       |       |       |--RPAREN -> ) [72:28]
|       |       |       |       `--OBJBLOCK -> OBJBLOCK [72:30]
|       |       |       |           |--LCURLY -> { [72:30]
|       |       |       |           |--METHOD_DEF -> METHOD_DEF [73:16]
|       |       |       |           |   |--MODIFIERS -> MODIFIERS [73:16]
|       |       |       |           |   |   `--LITERAL_PUBLIC -> public [73:16]
|       |       |       |           |   |--TYPE -> TYPE [73:23]
|       |       |       |           |   |   `--LITERAL_VOID -> void [73:23]
|       |       |       |           |   |--IDENT -> method [73:28]
|       |       |       |           |   |--LPAREN -> ( [73:34]
|       |       |       |           |   |--PARAMETERS -> PARAMETERS [73:35]
|       |       |       |           |   |--RPAREN -> ) [73:35]
|       |       |       |           |   `--SLIST -> { [73:37]
|       |       |       |           |       `--RCURLY -> } [73:38]
|       |       |       |           `--RCURLY -> } [74:12]
|       |       |       |--SEMI -> ; [74:13]
|       |       |       |--EXPR -> EXPR [75:14]
|       |       |       |   `--ASSIGN -> = [75:14]
|       |       |       |       |--IDENT -> v [75:12]
|       |       |       |       `--STRING_LITERAL -> "bad" [75:16]
|       |       |       |--SEMI -> ; [75:21]
|       |       |       `--RCURLY -> } [76:8]
|       |       |--LITERAL_FOR -> for [77:8]
|       |       |   |--LPAREN -> ( [77:12]
|       |       |   |--FOR_INIT -> FOR_INIT [77:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [77:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [77:13]
|       |       |   |       |--TYPE -> TYPE [77:13]
|       |       |   |       |   `--LITERAL_INT -> int [77:13]
|       |       |   |       |--IDENT -> i [77:17]
|       |       |   |       `--ASSIGN -> = [77:19]
|       |       |   |           `--EXPR -> EXPR [77:21]
|       |       |   |               `--NUM_INT -> 0 [77:21]
|       |       |   |--SEMI -> ; [77:22]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [77:26]
|       |       |   |   `--EXPR -> EXPR [77:26]
|       |       |   |       `--LT -> < [77:26]
|       |       |   |           |--IDENT -> i [77:24]
|       |       |   |           `--NUM_INT -> 10 [77:28]
|       |       |   |--SEMI -> ; [77:30]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [77:34]
|       |       |   |   `--ELIST -> ELIST [77:34]
|       |       |   |       `--EXPR -> EXPR [77:34]
|       |       |   |           `--PLUS_ASSIGN -> += [77:34]
|       |       |   |               |--IDENT -> i [77:32]
|       |       |   |               `--NUM_INT -> 1 [77:37]
|       |       |   |--RPAREN -> ) [77:38]
|       |       |   `--SLIST -> { [77:40]
|       |       |       |--LITERAL_FOR -> for [78:12]
|       |       |       |   |--LPAREN -> ( [78:16]
|       |       |       |   |--FOR_INIT -> FOR_INIT [78:19]
|       |       |       |   |   `--ELIST -> ELIST [78:19]
|       |       |       |   |       `--EXPR -> EXPR [78:19]
|       |       |       |   |           `--ASSIGN -> = [78:19]
|       |       |       |   |               |--IDENT -> i [78:17]
|       |       |       |   |               `--NUM_INT -> 7 [78:21]
|       |       |       |   |--SEMI -> ; [78:22]
|       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [78:26]
|       |       |       |   |   `--EXPR -> EXPR [78:26]
|       |       |       |   |       `--LT -> < [78:26]
|       |       |       |   |           |--IDENT -> i [78:24]
|       |       |       |   |           `--NUM_INT -> 10 [78:28]
|       |       |       |   |--SEMI -> ; [78:30]
|       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [78:34]
|       |       |       |   |   `--ELIST -> ELIST [78:34]
|       |       |       |   |       `--EXPR -> EXPR [78:34]
|       |       |       |   |           `--PLUS_ASSIGN -> += [78:34]
|       |       |       |   |               |--IDENT -> i [78:32]
|       |       |       |   |               `--NUM_INT -> 1 [78:37]
|       |       |       |   |--RPAREN -> ) [78:38]
|       |       |       |   `--SLIST -> { [78:40]
|       |       |       |       `--RCURLY -> } [78:41]
|       |       |       `--RCURLY -> } [79:8]
|       |       |--LITERAL_FOR -> for [80:8]
|       |       |   |--LPAREN -> ( [80:12]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [80:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [80:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [80:13]
|       |       |   |   |   |--TYPE -> TYPE [80:13]
|       |       |   |   |   |   `--IDENT -> String [80:13]
|       |       |   |   |   `--IDENT -> name [80:20]
|       |       |   |   |--COLON -> : [80:24]
|       |       |   |   `--EXPR -> EXPR [80:26]
|       |       |   |       `--LITERAL_NEW -> new [80:26]
|       |       |   |           |--IDENT -> String [80:30]
|       |       |   |           |--ARRAY_DECLARATOR -> [ [80:36]
|       |       |   |           |   `--RBRACK -> ] [80:37]
|       |       |   |           `--ARRAY_INIT -> { [80:39]
|       |       |   |               `--RCURLY -> } [80:40]
|       |       |   |--RPAREN -> ) [80:41]
|       |       |   `--SLIST -> { [80:43]
|       |       |       `--RCURLY -> } [81:8]
|       |       |--LITERAL_FOR -> for [83:8]
|       |       |   |--LPAREN -> ( [83:12]
|       |       |   |--FOR_INIT -> FOR_INIT [83:15]
|       |       |   |   `--ELIST -> ELIST [83:15]
|       |       |   |       `--EXPR -> EXPR [83:15]
|       |       |   |           `--ASSIGN -> = [83:15]
|       |       |   |               |--IDENT -> i [83:13]
|       |       |   |               `--NUM_INT -> 0 [83:17]
|       |       |   |--SEMI -> ; [83:18]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [83:22]
|       |       |   |   `--EXPR -> EXPR [83:22]
|       |       |   |       `--LT -> < [83:22]
|       |       |   |           |--IDENT -> i [83:20]
|       |       |   |           `--NUM_INT -> 10 [83:24]
|       |       |   |--SEMI -> ; [83:26]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [83:29]
|       |       |   |   `--ELIST -> ELIST [83:29]
|       |       |   |       `--EXPR -> EXPR [83:29]
|       |       |   |           `--POST_INC -> ++ [83:29]
|       |       |   |               `--IDENT -> i [83:28]
|       |       |   |--RPAREN -> ) [83:31]
|       |       |   `--SLIST -> { [83:33]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [84:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [84:12]
|       |       |       |   |--TYPE -> TYPE [84:12]
|       |       |       |   |   `--IDENT -> String [84:12]
|       |       |       |   `--IDENT -> name [84:19]
|       |       |       |--SEMI -> ; [84:23]
|       |       |       |--EXPR -> EXPR [85:17]
|       |       |       |   `--ASSIGN -> = [85:17]
|       |       |       |       |--IDENT -> name [85:12]
|       |       |       |       `--STRING_LITERAL -> "" [85:19]
|       |       |       |--SEMI -> ; [85:21]
|       |       |       `--RCURLY -> } [86:8]
|       |       |--LITERAL_FOR -> for [87:8]
|       |       |   |--LPAREN -> ( [87:12]
|       |       |   |--FOR_INIT -> FOR_INIT [87:13]
|       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [87:13]
|       |       |   |       |--MODIFIERS -> MODIFIERS [87:13]
|       |       |   |       |--TYPE -> TYPE [87:13]
|       |       |   |       |   `--LITERAL_INT -> int [87:13]
|       |       |   |       |--IDENT -> EXPR [87:17]
|       |       |   |       `--ASSIGN -> = [87:22]
|       |       |   |           `--EXPR -> EXPR [87:24]
|       |       |   |               `--NUM_INT -> 0 [87:24]
|       |       |   |--SEMI -> ; [87:25]
|       |       |   |--FOR_CONDITION -> FOR_CONDITION [87:32]
|       |       |   |   `--EXPR -> EXPR [87:32]
|       |       |   |       `--LT -> < [87:32]
|       |       |   |           |--IDENT -> EXPR [87:27]
|       |       |   |           `--NUM_INT -> 1 [87:34]
|       |       |   |--SEMI -> ; [87:35]
|       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [87:41]
|       |       |   |   `--ELIST -> ELIST [87:41]
|       |       |   |       `--EXPR -> EXPR [87:41]
|       |       |   |           `--POST_INC -> ++ [87:41]
|       |       |   |               `--IDENT -> EXPR [87:37]
|       |       |   |--RPAREN -> ) [87:43]
|       |       |   `--SLIST -> { [87:45]
|       |       |       |--LITERAL_FOR -> for [88:12]
|       |       |       |   |--LPAREN -> ( [88:16]
|       |       |       |   |--FOR_INIT -> FOR_INIT [88:17]
|       |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [88:17]
|       |       |       |   |       |--MODIFIERS -> MODIFIERS [88:17]
|       |       |       |   |       |--TYPE -> TYPE [88:17]
|       |       |       |   |       |   `--LITERAL_INT -> int [88:17]
|       |       |       |   |       |--IDENT -> j [88:21]
|       |       |       |   |       `--ASSIGN -> = [88:23]
|       |       |       |   |           `--EXPR -> EXPR [88:25]
|       |       |       |   |               `--NUM_INT -> 0 [88:25]
|       |       |       |   |--SEMI -> ; [88:26]
|       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [88:30]
|       |       |       |   |   `--EXPR -> EXPR [88:30]
|       |       |       |   |       `--LT -> < [88:30]
|       |       |       |   |           |--IDENT -> j [88:28]
|       |       |       |   |           `--NUM_INT -> 1 [88:32]
|       |       |       |   |--SEMI -> ; [88:33]
|       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [88:36]
|       |       |       |   |   `--ELIST -> ELIST [88:36]
|       |       |       |   |       `--EXPR -> EXPR [88:36]
|       |       |       |   |           `--POST_INC -> ++ [88:36]
|       |       |       |   |               `--IDENT -> i [88:35]
|       |       |       |   |--RPAREN -> ) [88:38]
|       |       |       |   `--SLIST -> { [88:40]
|       |       |       |       |--EXPR -> EXPR [89:17]
|       |       |       |       |   `--POST_INC -> ++ [89:17]
|       |       |       |       |       `--IDENT -> i [89:16]
|       |       |       |       |--SEMI -> ; [89:19]
|       |       |       |       `--RCURLY -> } [90:12]
|       |       |       `--RCURLY -> } [91:8]
|       |       `--RCURLY -> } [92:4]
|       |--VARIABLE_DEF -> VARIABLE_DEF [93:4]
|       |   |--MODIFIERS -> MODIFIERS [93:4]
|       |   |   `--LITERAL_PRIVATE -> private [93:4]
|       |   |--TYPE -> TYPE [93:12]
|       |   |   `--LITERAL_INT -> int [93:12]
|       |   |--IDENT -> i [93:16]
|       |   `--SEMI -> ; [93:17]
|       `--RCURLY -> } [94:0]
|--CLASS_DEF -> CLASS_DEF [96:0]
|   |--MODIFIERS -> MODIFIERS [96:0]
|   |   `--ANNOTATION -> ANNOTATION [96:0]
|   |       |--AT -> @ [96:0]
|   |       |--IDENT -> SuppressWarnings [96:1]
|   |       |--LPAREN -> ( [96:17]
|   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [96:18]
|   |       |   |--IDENT -> value [96:18]
|   |       |   |--ASSIGN -> = [96:24]
|   |       |   `--EXPR -> EXPR [96:26]
|   |       |       `--STRING_LITERAL -> "this previously caused NullPointerException" [96:26]
|   |       `--RPAREN -> ) [96:71]
|   |--LITERAL_CLASS -> class [97:0]
|   |--IDENT -> VariableDeclaredBeforeTheFirstBlockBegins [97:6]
|   `--OBJBLOCK -> OBJBLOCK [97:48]
|       |--LCURLY -> { [97:48]
|       |--METHOD_DEF -> METHOD_DEF [98:4]
|       |   |--MODIFIERS -> MODIFIERS [98:4]
|       |   |--TYPE -> TYPE [98:4]
|       |   |   `--LITERAL_VOID -> void [98:4]
|       |   |--IDENT -> foo [98:9]
|       |   |--LPAREN -> ( [98:12]
|       |   |--PARAMETERS -> PARAMETERS [98:13]
|       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [98:13]
|       |   |       |--MODIFIERS -> MODIFIERS [98:13]
|       |   |       |--TYPE -> TYPE [98:13]
|       |   |       |   |--IDENT -> String [98:13]
|       |   |       |   `--ARRAY_DECLARATOR -> [ [98:19]
|       |   |       |       `--RBRACK -> ] [98:20]
|       |   |       `--IDENT -> requests [98:22]
|       |   |--RPAREN -> ) [98:30]
|       |   `--SLIST -> { [98:32]
|       |       |--VARIABLE_DEF -> VARIABLE_DEF [99:8]
|       |       |   |--MODIFIERS -> MODIFIERS [99:8]
|       |       |   |--TYPE -> TYPE [99:8]
|       |       |   |   `--IDENT -> Class [99:8]
|       |       |   |--IDENT -> mUse4 [99:14]
|       |       |   `--ASSIGN -> = [99:20]
|       |       |       `--EXPR -> EXPR [99:45]
|       |       |           `--DOT -> . [99:45]
|       |       |               |--DOT -> . [99:31]
|       |       |               |   |--DOT -> . [99:26]
|       |       |               |   |   |--IDENT -> java [99:22]
|       |       |               |   |   `--IDENT -> util [99:27]
|       |       |               |   |--IDENT -> Enumeration [99:32]
|       |       |               |   `--ARRAY_DECLARATOR -> [ [99:43]
|       |       |               |       `--RBRACK -> ] [99:44]
|       |       |               `--LITERAL_CLASS -> class [99:46]
|       |       |--SEMI -> ; [99:51]
|       |       |--LITERAL_FOR -> for [100:8]
|       |       |   |--LPAREN -> ( [100:12]
|       |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [100:13]
|       |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [100:13]
|       |       |   |   |   |--MODIFIERS -> MODIFIERS [100:13]
|       |       |   |   |   |--TYPE -> TYPE [100:13]
|       |       |   |   |   |   `--IDENT -> String [100:13]
|       |       |   |   |   `--IDENT -> eventDataType [100:20]
|       |       |   |   |--COLON -> : [100:34]
|       |       |   |   `--EXPR -> EXPR [100:36]
|       |       |   |       `--IDENT -> requests [100:36]
|       |       |   |--RPAREN -> ) [100:44]
|       |       |   `--SLIST -> { [100:46]
|       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [101:12]
|       |       |       |   |--MODIFIERS -> MODIFIERS [101:12]
|       |       |       |   |   `--ANNOTATION -> ANNOTATION [101:12]
|       |       |       |   |       |--AT -> @ [101:12]
|       |       |       |   |       |--IDENT -> SuppressWarnings [101:13]
|       |       |       |   |       |--LPAREN -> ( [101:29]
|       |       |       |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [101:30]
|       |       |       |   |       |   |--IDENT -> value [101:30]
|       |       |       |   |       |   |--ASSIGN -> = [101:36]
|       |       |       |   |       |   `--EXPR -> EXPR [101:38]
|       |       |       |   |       |       `--STRING_LITERAL -> "this previously caused NullPointerException" [101:38]
|       |       |       |   |       `--RPAREN -> ) [101:83]
|       |       |       |   |--TYPE -> TYPE [102:12]
|       |       |       |   |   `--IDENT -> String [102:12]
|       |       |       |   `--IDENT -> eventData [102:19]
|       |       |       |--SEMI -> ; [102:28]
|       |       |       `--RCURLY -> } [103:8]
|       |       `--RCURLY -> } [104:4]
|       `--RCURLY -> } [105:0]
`--CLASS_DEF -> CLASS_DEF [106:0]
    |--MODIFIERS -> MODIFIERS [106:0]
    |   `--ABSTRACT -> abstract [106:0]
    |--LITERAL_CLASS -> class [106:9]
    |--IDENT -> NestedClass [106:15]
    `--OBJBLOCK -> OBJBLOCK [106:27]
        |--LCURLY -> { [106:27]
        |--METHOD_DEF -> METHOD_DEF [107:4]
        |   |--MODIFIERS -> MODIFIERS [107:4]
        |   |   |--LITERAL_PUBLIC -> public [107:4]
        |   |   `--ABSTRACT -> abstract [107:11]
        |   |--TYPE -> TYPE [107:20]
        |   |   `--LITERAL_VOID -> void [107:20]
        |   |--IDENT -> method [107:25]
        |   |--LPAREN -> ( [107:31]
        |   |--PARAMETERS -> PARAMETERS [107:32]
        |   |--RPAREN -> ) [107:32]
        |   `--SEMI -> ; [107:33]
        `--RCURLY -> } [108:0]
