PACKAGE_DEF -> package [2:0]
|--ANNOTATIONS -> ANNOTATIONS [2:47]
|--DOT -> . [2:47]
|   |--DOT -> . [2:39]
|   |   |--DOT -> . [2:28]
|   |   |   |--DOT -> . [2:22]
|   |   |   |   |--DOT -> . [2:11]
|   |   |   |   |   |--IDENT -> com [2:8]
|   |   |   |   |   `--IDENT -> puppycrawl [2:12]
|   |   |   |   `--IDENT -> tools [2:23]
|   |   |   `--IDENT -> checkstyle [2:29]
|   |   `--IDENT -> grammar [2:40]
|   `--IDENT -> java14 [2:48]
`--SEMI -> ; [2:54]
IMPORT -> import [4:0]
|--DOT -> . [4:14]
|   |--DOT -> . [4:11]
|   |   |--IDENT -> java [4:7]
|   |   `--IDENT -> io [4:12]
|   `--IDENT -> IOException [4:15]
`--SEMI -> ; [4:26]
IMPORT -> import [5:0]
|--DOT -> . [5:14]
|   |--DOT -> . [5:11]
|   |   |--IDENT -> java [5:7]
|   |   `--IDENT -> io [5:12]
|   `--IDENT -> Serializable [5:15]
`--SEMI -> ; [5:27]
IMPORT -> import [6:0]
|--DOT -> . [6:27]
|   |--DOT -> . [6:16]
|   |   |--DOT -> . [6:11]
|   |   |   |--IDENT -> java [6:7]
|   |   |   `--IDENT -> lang [6:12]
|   |   `--IDENT -> annotation [6:17]
|   `--IDENT -> Native [6:28]
`--SEMI -> ; [6:34]
IMPORT -> import [7:0]
|--DOT -> . [7:20]
|   |--DOT -> . [7:15]
|   |   |--DOT -> . [7:11]
|   |   |   |--IDENT -> java [7:7]
|   |   |   `--IDENT -> nio [7:12]
|   |   `--IDENT -> file [7:16]
|   `--IDENT -> Files [7:21]
`--SEMI -> ; [7:26]
IMPORT -> import [8:0]
|--DOT -> . [8:16]
|   |--DOT -> . [8:11]
|   |   |--IDENT -> java [8:7]
|   |   `--IDENT -> time [8:12]
|   `--IDENT -> LocalDateTime [8:17]
`--SEMI -> ; [8:30]
IMPORT -> import [9:0]
|--DOT -> . [9:16]
|   |--DOT -> . [9:11]
|   |   |--IDENT -> java [9:7]
|   |   `--IDENT -> util [9:12]
|   `--IDENT -> Objects [9:17]
`--SEMI -> ; [9:24]
IMPORT -> import [10:0]
|--DOT -> . [10:27]
|   |--DOT -> . [10:16]
|   |   |--DOT -> . [10:11]
|   |   |   |--IDENT -> java [10:7]
|   |   |   `--IDENT -> util [10:12]
|   |   `--IDENT -> concurrent [10:17]
|   `--IDENT -> TimeUnit [10:28]
`--SEMI -> ; [10:36]
IMPORT -> import [11:0]
|--DOT -> . [11:24]
|   |--DOT -> . [11:16]
|   |   |--DOT -> . [11:11]
|   |   |   |--IDENT -> java [11:7]
|   |   |   `--IDENT -> util [11:12]
|   |   `--IDENT -> logging [11:17]
|   `--IDENT -> Level [11:25]
`--SEMI -> ; [11:30]
IMPORT -> import [12:0]
|--DOT -> . [12:24]
|   |--DOT -> . [12:16]
|   |   |--DOT -> . [12:11]
|   |   |   |--IDENT -> java [12:7]
|   |   |   `--IDENT -> util [12:12]
|   |   `--IDENT -> logging [12:17]
|   `--IDENT -> LogRecord [12:25]
`--SEMI -> ; [12:34]
IMPORT -> import [14:0]
|--DOT -> . [14:18]
|   |--DOT -> . [14:14]
|   |   |--DOT -> . [14:10]
|   |   |   |--IDENT -> org [14:7]
|   |   |   `--IDENT -> w3c [14:11]
|   |   `--IDENT -> dom [14:15]
|   `--IDENT -> Node [14:19]
`--SEMI -> ; [14:23]
CLASS_DEF -> CLASS_DEF [19:0]
|--MODIFIERS -> MODIFIERS [19:0]
|   `--LITERAL_PUBLIC -> public [19:0]
|--LITERAL_CLASS -> class [19:7]
|--IDENT -> InputJava14Records [19:13]
`--OBJBLOCK -> OBJBLOCK [20:0]
    |--LCURLY -> { [20:0]
    |--METHOD_DEF -> METHOD_DEF [21:4]
    |   |--MODIFIERS -> MODIFIERS [21:4]
    |   |   |--LITERAL_PUBLIC -> public [21:4]
    |   |   `--LITERAL_STATIC -> static [21:11]
    |   |--TYPE -> TYPE [21:18]
    |   |   `--LITERAL_INT -> int [21:18]
    |   |--IDENT -> getRecord [21:22]
    |   |--LPAREN -> ( [21:31]
    |   |--PARAMETERS -> PARAMETERS [21:32]
    |   |--RPAREN -> ) [21:32]
    |   `--SLIST -> { [21:34]
    |       |--LITERAL_RETURN -> return [22:8]
    |       |   |--EXPR -> EXPR [22:15]
    |       |   |   `--IDENT -> record [22:15]
    |       |   `--SEMI -> ; [22:21]
    |       `--RCURLY -> } [23:4]
    |--METHOD_DEF -> METHOD_DEF [25:4]
    |   |--MODIFIERS -> MODIFIERS [25:4]
    |   |   |--LITERAL_PUBLIC -> public [25:4]
    |   |   `--LITERAL_STATIC -> static [25:11]
    |   |--TYPE -> TYPE [25:18]
    |   |   `--LITERAL_VOID -> void [25:18]
    |   |--IDENT -> setRecord [25:23]
    |   |--LPAREN -> ( [25:32]
    |   |--PARAMETERS -> PARAMETERS [25:33]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:33]
    |   |       |--MODIFIERS -> MODIFIERS [25:33]
    |   |       |--TYPE -> TYPE [25:33]
    |   |       |   `--LITERAL_INT -> int [25:33]
    |   |       `--IDENT -> record [25:37]
    |   |--RPAREN -> ) [25:43]
    |   `--SLIST -> { [25:45]
    |       |--EXPR -> EXPR [26:34]
    |       |   `--ASSIGN -> = [26:34]
    |       |       |--DOT -> . [26:26]
    |       |       |   |--IDENT -> InputJava14Records [26:8]
    |       |       |   `--IDENT -> record [26:27]
    |       |       `--IDENT -> record [26:36]
    |       |--SEMI -> ; [26:42]
    |       `--RCURLY -> } [27:4]
    |--ANNOTATION_DEF -> ANNOTATION_DEF [30:4]
    |   |--MODIFIERS -> MODIFIERS [30:4]
    |   |   `--LITERAL_PUBLIC -> public [30:4]
    |   |--AT -> @ [30:11]
    |   |--LITERAL_INTERFACE -> interface [30:12]
    |   |--IDENT -> NonNull1 [30:22]
    |   `--OBJBLOCK -> OBJBLOCK [30:31]
    |       |--LCURLY -> { [30:31]
    |       `--RCURLY -> } [30:32]
    |--RECORD_DEF -> RECORD_DEF [31:4]
    |   |--MODIFIERS -> MODIFIERS [31:4]
    |   |   `--LITERAL_PUBLIC -> public [31:4]
    |   |--LITERAL_RECORD -> record [31:11]
    |   |--IDENT -> AnnotatedBinaryNode [31:18]
    |   |--LPAREN -> ( [31:37]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [31:38]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [31:38]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [31:38]
    |   |   |   |   |--ANNOTATION -> ANNOTATION [31:38]
    |   |   |   |   |   |--AT -> @ [31:38]
    |   |   |   |   |   `--IDENT -> Native [31:39]
    |   |   |   |   `--ANNOTATION -> ANNOTATION [31:46]
    |   |   |   |       |--AT -> @ [31:46]
    |   |   |   |       `--IDENT -> NonNull1 [31:47]
    |   |   |   |--TYPE -> TYPE [31:56]
    |   |   |   |   `--IDENT -> Node [31:56]
    |   |   |   `--IDENT -> left [31:61]
    |   |   |--COMMA -> , [31:65]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [31:67]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [31:67]
    |   |       |   `--ANNOTATION -> ANNOTATION [31:67]
    |   |       |       |--AT -> @ [31:67]
    |   |       |       `--IDENT -> NonNull1 [31:68]
    |   |       |--TYPE -> TYPE [31:77]
    |   |       |   `--IDENT -> Node [31:77]
    |   |       `--IDENT -> right [31:82]
    |   |--RPAREN -> ) [31:87]
    |   `--OBJBLOCK -> OBJBLOCK [31:89]
    |       |--LCURLY -> { [31:89]
    |       `--RCURLY -> } [31:91]
    |--INTERFACE_DEF -> INTERFACE_DEF [33:4]
    |   |--MODIFIERS -> MODIFIERS [33:4]
    |   |   `--LITERAL_PUBLIC -> public [33:4]
    |   |--LITERAL_INTERFACE -> interface [33:11]
    |   |--IDENT -> Coords [33:21]
    |   `--OBJBLOCK -> OBJBLOCK [33:28]
    |       |--LCURLY -> { [33:28]
    |       |--METHOD_DEF -> METHOD_DEF [34:8]
    |       |   |--MODIFIERS -> MODIFIERS [34:8]
    |       |   |   `--LITERAL_PUBLIC -> public [34:8]
    |       |   |--TYPE -> TYPE [34:15]
    |       |   |   `--LITERAL_DOUBLE -> double [34:15]
    |       |   |--IDENT -> x [34:22]
    |       |   |--LPAREN -> ( [34:23]
    |       |   |--PARAMETERS -> PARAMETERS [34:24]
    |       |   |--RPAREN -> ) [34:24]
    |       |   `--SEMI -> ; [34:25]
    |       |--METHOD_DEF -> METHOD_DEF [35:8]
    |       |   |--MODIFIERS -> MODIFIERS [35:8]
    |       |   |   `--LITERAL_PUBLIC -> public [35:8]
    |       |   |--TYPE -> TYPE [35:15]
    |       |   |   `--LITERAL_DOUBLE -> double [35:15]
    |       |   |--IDENT -> y [35:22]
    |       |   |--LPAREN -> ( [35:23]
    |       |   |--PARAMETERS -> PARAMETERS [35:24]
    |       |   |--RPAREN -> ) [35:24]
    |       |   `--SEMI -> ; [35:25]
    |       `--RCURLY -> } [36:4]
    |--RECORD_DEF -> RECORD_DEF [39:4]
    |   |--MODIFIERS -> MODIFIERS [39:4]
    |   |   `--LITERAL_PUBLIC -> public [39:4]
    |   |--LITERAL_RECORD -> record [39:11]
    |   |--IDENT -> Polar [39:18]
    |   |--IMPLEMENTS_CLAUSE -> implements [39:48]
    |   |   `--IDENT -> Coords [39:59]
    |   |--LPAREN -> ( [39:23]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [39:24]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [39:24]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [39:24]
    |   |   |   |--TYPE -> TYPE [39:24]
    |   |   |   |   `--LITERAL_DOUBLE -> double [39:24]
    |   |   |   `--IDENT -> r [39:31]
    |   |   |--COMMA -> , [39:32]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [39:34]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [39:34]
    |   |       |--TYPE -> TYPE [39:34]
    |   |       |   `--LITERAL_DOUBLE -> double [39:34]
    |   |       `--IDENT -> theta [39:41]
    |   |--RPAREN -> ) [39:46]
    |   `--OBJBLOCK -> OBJBLOCK [39:66]
    |       |--LCURLY -> { [39:66]
    |       |--METHOD_DEF -> METHOD_DEF [40:8]
    |       |   |--MODIFIERS -> MODIFIERS [40:8]
    |       |   |   |--ANNOTATION -> ANNOTATION [40:8]
    |       |   |   |   |--AT -> @ [40:8]
    |       |   |   |   `--IDENT -> Override [40:9]
    |       |   |   `--LITERAL_PUBLIC -> public [41:8]
    |       |   |--TYPE -> TYPE [41:15]
    |       |   |   `--LITERAL_DOUBLE -> double [41:15]
    |       |   |--IDENT -> x [41:22]
    |       |   |--LPAREN -> ( [41:23]
    |       |   |--PARAMETERS -> PARAMETERS [41:24]
    |       |   |--RPAREN -> ) [41:24]
    |       |   `--SLIST -> { [41:26]
    |       |       |--LITERAL_RETURN -> return [42:12]
    |       |       |   |--EXPR -> EXPR [42:21]
    |       |       |   |   `--STAR -> * [42:21]
    |       |       |   |       |--IDENT -> r [42:19]
    |       |       |   |       `--METHOD_CALL -> ( [42:31]
    |       |       |   |           |--DOT -> . [42:27]
    |       |       |   |           |   |--IDENT -> Math [42:23]
    |       |       |   |           |   `--IDENT -> cos [42:28]
    |       |       |   |           |--ELIST -> ELIST [42:32]
    |       |       |   |           |   `--EXPR -> EXPR [42:32]
    |       |       |   |           |       `--IDENT -> theta [42:32]
    |       |       |   |           `--RPAREN -> ) [42:37]
    |       |       |   `--SEMI -> ; [42:38]
    |       |       `--RCURLY -> } [43:8]
    |       |--METHOD_DEF -> METHOD_DEF [45:8]
    |       |   |--MODIFIERS -> MODIFIERS [45:8]
    |       |   |   |--ANNOTATION -> ANNOTATION [45:8]
    |       |   |   |   |--AT -> @ [45:8]
    |       |   |   |   `--IDENT -> Override [45:9]
    |       |   |   `--LITERAL_PUBLIC -> public [46:8]
    |       |   |--TYPE -> TYPE [46:15]
    |       |   |   `--LITERAL_DOUBLE -> double [46:15]
    |       |   |--IDENT -> y [46:22]
    |       |   |--LPAREN -> ( [46:23]
    |       |   |--PARAMETERS -> PARAMETERS [46:24]
    |       |   |--RPAREN -> ) [46:24]
    |       |   `--SLIST -> { [46:26]
    |       |       |--LITERAL_RETURN -> return [47:12]
    |       |       |   |--EXPR -> EXPR [47:21]
    |       |       |   |   `--STAR -> * [47:21]
    |       |       |   |       |--IDENT -> r [47:19]
    |       |       |   |       `--METHOD_CALL -> ( [47:31]
    |       |       |   |           |--DOT -> . [47:27]
    |       |       |   |           |   |--IDENT -> Math [47:23]
    |       |       |   |           |   `--IDENT -> sin [47:28]
    |       |       |   |           |--ELIST -> ELIST [47:32]
    |       |       |   |           |   `--EXPR -> EXPR [47:32]
    |       |       |   |           |       `--IDENT -> theta [47:32]
    |       |       |   |           `--RPAREN -> ) [47:37]
    |       |       |   `--SEMI -> ; [47:38]
    |       |       `--RCURLY -> } [48:8]
    |       `--RCURLY -> } [49:4]
    |--RECORD_DEF -> RECORD_DEF [52:4]
    |   |--MODIFIERS -> MODIFIERS [52:4]
    |   |   `--LITERAL_PUBLIC -> public [52:4]
    |   |--LITERAL_RECORD -> record [52:11]
    |   |--IDENT -> Holder [52:18]
    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [52:24]
    |   |   |--GENERIC_START -> < [52:24]
    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [52:25]
    |   |   |   `--IDENT -> T [52:25]
    |   |   `--GENERIC_END -> > [52:26]
    |   |--LPAREN -> ( [52:27]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [52:28]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [52:28]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [52:28]
    |   |       |--TYPE -> TYPE [52:28]
    |   |       |   `--IDENT -> T [52:28]
    |   |       `--IDENT -> t [52:30]
    |   |--RPAREN -> ) [52:31]
    |   `--OBJBLOCK -> OBJBLOCK [52:33]
    |       |--LCURLY -> { [52:33]
    |       `--RCURLY -> } [52:35]
    |--RECORD_DEF -> RECORD_DEF [54:4]
    |   |--MODIFIERS -> MODIFIERS [54:4]
    |   |   `--LITERAL_PUBLIC -> public [54:4]
    |   |--LITERAL_RECORD -> record [54:11]
    |   |--IDENT -> HolderG [54:18]
    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [54:25]
    |   |   |--GENERIC_START -> < [54:25]
    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [54:26]
    |   |   |   `--IDENT -> G [54:26]
    |   |   `--GENERIC_END -> > [54:27]
    |   |--LPAREN -> ( [54:28]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [54:29]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [54:29]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [54:29]
    |   |       |--TYPE -> TYPE [54:29]
    |   |       |   `--IDENT -> G [54:29]
    |   |       `--IDENT -> g [54:31]
    |   |--RPAREN -> ) [54:32]
    |   `--OBJBLOCK -> OBJBLOCK [54:34]
    |       |--LCURLY -> { [54:34]
    |       |--METHOD_DEF -> METHOD_DEF [56:8]
    |       |   |--MODIFIERS -> MODIFIERS [56:8]
    |       |   |   |--ANNOTATION -> ANNOTATION [56:8]
    |       |   |   |   |--AT -> @ [56:8]
    |       |   |   |   `--IDENT -> Override [56:9]
    |       |   |   `--LITERAL_PUBLIC -> public [57:8]
    |       |   |--TYPE -> TYPE [57:15]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [57:15]
    |       |   |--IDENT -> equals [57:23]
    |       |   |--LPAREN -> ( [57:29]
    |       |   |--PARAMETERS -> PARAMETERS [57:30]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [57:30]
    |       |   |       |--MODIFIERS -> MODIFIERS [57:30]
    |       |   |       |--TYPE -> TYPE [57:30]
    |       |   |       |   `--IDENT -> Object [57:30]
    |       |   |       `--IDENT -> o [57:37]
    |       |   |--RPAREN -> ) [57:38]
    |       |   `--SLIST -> { [57:40]
    |       |       |--LITERAL_IF -> if [58:12]
    |       |       |   |--LPAREN -> ( [58:15]
    |       |       |   |--EXPR -> EXPR [58:21]
    |       |       |   |   `--EQUAL -> == [58:21]
    |       |       |   |       |--LITERAL_THIS -> this [58:16]
    |       |       |   |       `--IDENT -> o [58:24]
    |       |       |   |--RPAREN -> ) [58:25]
    |       |       |   `--LITERAL_RETURN -> return [58:27]
    |       |       |       |--EXPR -> EXPR [58:34]
    |       |       |       |   `--LITERAL_TRUE -> true [58:34]
    |       |       |       `--SEMI -> ; [58:38]
    |       |       |--LITERAL_IF -> if [59:12]
    |       |       |   |--LPAREN -> ( [59:15]
    |       |       |   |--EXPR -> EXPR [59:26]
    |       |       |   |   `--LOR -> || [59:26]
    |       |       |   |       |--EQUAL -> == [59:18]
    |       |       |   |       |   |--IDENT -> o [59:16]
    |       |       |   |       |   `--LITERAL_NULL -> null [59:21]
    |       |       |   |       `--NOT_EQUAL -> != [59:40]
    |       |       |   |           |--METHOD_CALL -> ( [59:37]
    |       |       |   |           |   |--IDENT -> getClass [59:29]
    |       |       |   |           |   |--ELIST -> ELIST [59:38]
    |       |       |   |           |   `--RPAREN -> ) [59:38]
    |       |       |   |           `--METHOD_CALL -> ( [59:53]
    |       |       |   |               |--DOT -> . [59:44]
    |       |       |   |               |   |--IDENT -> o [59:43]
    |       |       |   |               |   `--IDENT -> getClass [59:45]
    |       |       |   |               |--ELIST -> ELIST [59:54]
    |       |       |   |               `--RPAREN -> ) [59:54]
    |       |       |   |--RPAREN -> ) [59:55]
    |       |       |   `--LITERAL_RETURN -> return [59:57]
    |       |       |       |--EXPR -> EXPR [59:64]
    |       |       |       |   `--LITERAL_FALSE -> false [59:64]
    |       |       |       `--SEMI -> ; [59:69]
    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [60:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [60:12]
    |       |       |   |--TYPE -> TYPE [60:12]
    |       |       |   |   |--IDENT -> HolderG [60:12]
    |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [60:19]
    |       |       |   |       |--GENERIC_START -> < [60:19]
    |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [60:20]
    |       |       |   |       |   `--WILDCARD_TYPE -> ? [60:20]
    |       |       |   |       `--GENERIC_END -> > [60:21]
    |       |       |   |--IDENT -> holderG [60:23]
    |       |       |   `--ASSIGN -> = [60:31]
    |       |       |       `--EXPR -> EXPR [60:33]
    |       |       |           `--TYPECAST -> ( [60:33]
    |       |       |               |--TYPE -> TYPE [60:34]
    |       |       |               |   |--IDENT -> HolderG [60:34]
    |       |       |               |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [60:41]
    |       |       |               |       |--GENERIC_START -> < [60:41]
    |       |       |               |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [60:42]
    |       |       |               |       |   `--WILDCARD_TYPE -> ? [60:42]
    |       |       |               |       `--GENERIC_END -> > [60:43]
    |       |       |               |--RPAREN -> ) [60:44]
    |       |       |               `--IDENT -> o [60:46]
    |       |       |--SEMI -> ; [60:47]
    |       |       |--LITERAL_RETURN -> return [61:12]
    |       |       |   |--EXPR -> EXPR [61:33]
    |       |       |   |   `--METHOD_CALL -> ( [61:33]
    |       |       |   |       |--DOT -> . [61:26]
    |       |       |   |       |   |--IDENT -> Objects [61:19]
    |       |       |   |       |   `--IDENT -> equals [61:27]
    |       |       |   |       |--ELIST -> ELIST [61:34]
    |       |       |   |       |   |--EXPR -> EXPR [61:34]
    |       |       |   |       |   |   `--IDENT -> g [61:34]
    |       |       |   |       |   |--COMMA -> , [61:35]
    |       |       |   |       |   `--EXPR -> EXPR [61:44]
    |       |       |   |       |       `--DOT -> . [61:44]
    |       |       |   |       |           |--IDENT -> holderG [61:37]
    |       |       |   |       |           `--IDENT -> g [61:45]
    |       |       |   |       `--RPAREN -> ) [61:46]
    |       |       |   `--SEMI -> ; [61:47]
    |       |       `--RCURLY -> } [62:8]
    |       |--METHOD_DEF -> METHOD_DEF [64:8]
    |       |   |--MODIFIERS -> MODIFIERS [64:8]
    |       |   |   |--ANNOTATION -> ANNOTATION [64:8]
    |       |   |   |   |--AT -> @ [64:8]
    |       |   |   |   `--IDENT -> Override [64:9]
    |       |   |   `--LITERAL_PUBLIC -> public [65:8]
    |       |   |--TYPE -> TYPE [65:15]
    |       |   |   `--LITERAL_INT -> int [65:15]
    |       |   |--IDENT -> hashCode [65:19]
    |       |   |--LPAREN -> ( [65:27]
    |       |   |--PARAMETERS -> PARAMETERS [65:28]
    |       |   |--RPAREN -> ) [65:28]
    |       |   `--SLIST -> { [65:30]
    |       |       |--LITERAL_RETURN -> return [66:12]
    |       |       |   |--EXPR -> EXPR [66:31]
    |       |       |   |   `--METHOD_CALL -> ( [66:31]
    |       |       |   |       |--DOT -> . [66:26]
    |       |       |   |       |   |--IDENT -> Objects [66:19]
    |       |       |   |       |   `--IDENT -> hash [66:27]
    |       |       |   |       |--ELIST -> ELIST [66:32]
    |       |       |   |       |   `--EXPR -> EXPR [66:32]
    |       |       |   |       |       `--IDENT -> g [66:32]
    |       |       |   |       `--RPAREN -> ) [66:33]
    |       |       |   `--SEMI -> ; [66:34]
    |       |       `--RCURLY -> } [67:8]
    |       `--RCURLY -> } [68:4]
    |--RECORD_DEF -> RECORD_DEF [72:4]
    |   |--MODIFIERS -> MODIFIERS [72:4]
    |   |   `--LITERAL_PUBLIC -> public [72:4]
    |   |--LITERAL_RECORD -> record [72:11]
    |   |--IDENT -> Car [72:18]
    |   |--LPAREN -> ( [72:21]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [72:22]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [72:22]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [72:22]
    |   |   |   |--TYPE -> TYPE [72:22]
    |   |   |   |   `--IDENT -> String [72:22]
    |   |   |   `--IDENT -> color [72:29]
    |   |   |--COMMA -> , [72:34]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [72:36]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [72:36]
    |   |       |--TYPE -> TYPE [72:36]
    |   |       |   `--IDENT -> String [72:36]
    |   |       `--IDENT -> model [72:43]
    |   |--RPAREN -> ) [72:48]
    |   `--OBJBLOCK -> OBJBLOCK [72:50]
    |       |--LCURLY -> { [72:50]
    |       `--RCURLY -> } [72:51]
    |--RECORD_DEF -> RECORD_DEF [75:4]
    |   |--MODIFIERS -> MODIFIERS [75:4]
    |   |   `--LITERAL_PUBLIC -> public [75:4]
    |   |--LITERAL_RECORD -> record [75:11]
    |   |--IDENT -> Thing [75:18]
    |   |--LPAREN -> ( [75:23]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [75:24]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [75:24]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [75:24]
    |   |   |   |--TYPE -> TYPE [75:24]
    |   |   |   |   `--IDENT -> String [75:24]
    |   |   |   `--IDENT -> name1 [75:31]
    |   |   |--COMMA -> , [75:36]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [75:38]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [75:38]
    |   |       |--TYPE -> TYPE [75:38]
    |   |       |   `--IDENT -> String [75:38]
    |   |       `--IDENT -> name2 [75:45]
    |   |--RPAREN -> ) [75:50]
    |   `--OBJBLOCK -> OBJBLOCK [75:52]
    |       |--LCURLY -> { [75:52]
    |       |--COMPACT_CTOR_DEF -> COMPACT_CTOR_DEF [76:8]
    |       |   |--MODIFIERS -> MODIFIERS [76:8]
    |       |   |   `--LITERAL_PUBLIC -> public [76:8]
    |       |   |--IDENT -> Thing [76:15]
    |       |   `--SLIST -> { [76:21]
    |       |       |--EXPR -> EXPR [77:34]
    |       |       |   `--METHOD_CALL -> ( [77:34]
    |       |       |       |--DOT -> . [77:19]
    |       |       |       |   |--IDENT -> Objects [77:12]
    |       |       |       |   `--IDENT -> requireNonNull [77:20]
    |       |       |       |--ELIST -> ELIST [77:35]
    |       |       |       |   `--EXPR -> EXPR [77:35]
    |       |       |       |       `--IDENT -> name1 [77:35]
    |       |       |       `--RPAREN -> ) [77:40]
    |       |       |--SEMI -> ; [77:41]
    |       |       |--EXPR -> EXPR [78:34]
    |       |       |   `--METHOD_CALL -> ( [78:34]
    |       |       |       |--DOT -> . [78:19]
    |       |       |       |   |--IDENT -> Objects [78:12]
    |       |       |       |   `--IDENT -> requireNonNull [78:20]
    |       |       |       |--ELIST -> ELIST [78:35]
    |       |       |       |   `--EXPR -> EXPR [78:35]
    |       |       |       |       `--IDENT -> name2 [78:35]
    |       |       |       `--RPAREN -> ) [78:40]
    |       |       |--SEMI -> ; [78:41]
    |       |       `--RCURLY -> } [79:8]
    |       `--RCURLY -> } [80:4]
    |--RECORD_DEF -> RECORD_DEF [82:4]
    |   |--MODIFIERS -> MODIFIERS [82:4]
    |   |   `--LITERAL_PUBLIC -> public [82:4]
    |   |--LITERAL_RECORD -> record [82:11]
    |   |--IDENT -> ThingAnnotatedConstructor [82:18]
    |   |--LPAREN -> ( [82:43]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [82:44]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [82:44]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [82:44]
    |   |   |   |--TYPE -> TYPE [82:44]
    |   |   |   |   `--IDENT -> String [82:44]
    |   |   |   `--IDENT -> name1 [82:51]
    |   |   |--COMMA -> , [82:56]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [82:58]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [82:58]
    |   |       |--TYPE -> TYPE [82:58]
    |   |       |   `--IDENT -> String [82:58]
    |   |       `--IDENT -> name2 [82:65]
    |   |--RPAREN -> ) [82:70]
    |   `--OBJBLOCK -> OBJBLOCK [82:72]
    |       |--LCURLY -> { [82:72]
    |       |--COMPACT_CTOR_DEF -> COMPACT_CTOR_DEF [83:8]
    |       |   |--MODIFIERS -> MODIFIERS [83:8]
    |       |   |   |--ANNOTATION -> ANNOTATION [83:8]
    |       |   |   |   |--AT -> @ [83:8]
    |       |   |   |   `--IDENT -> NonNull1 [83:9]
    |       |   |   `--LITERAL_PUBLIC -> public [84:8]
    |       |   |--IDENT -> ThingAnnotatedConstructor [84:15]
    |       |   `--SLIST -> { [84:41]
    |       |       |--EXPR -> EXPR [85:34]
    |       |       |   `--METHOD_CALL -> ( [85:34]
    |       |       |       |--DOT -> . [85:19]
    |       |       |       |   |--IDENT -> Objects [85:12]
    |       |       |       |   `--IDENT -> requireNonNull [85:20]
    |       |       |       |--ELIST -> ELIST [85:35]
    |       |       |       |   `--EXPR -> EXPR [85:35]
    |       |       |       |       `--IDENT -> name1 [85:35]
    |       |       |       `--RPAREN -> ) [85:40]
    |       |       |--SEMI -> ; [85:41]
    |       |       |--EXPR -> EXPR [86:34]
    |       |       |   `--METHOD_CALL -> ( [86:34]
    |       |       |       |--DOT -> . [86:19]
    |       |       |       |   |--IDENT -> Objects [86:12]
    |       |       |       |   `--IDENT -> requireNonNull [86:20]
    |       |       |       |--ELIST -> ELIST [86:35]
    |       |       |       |   `--EXPR -> EXPR [86:35]
    |       |       |       |       `--IDENT -> name2 [86:35]
    |       |       |       `--RPAREN -> ) [86:40]
    |       |       |--SEMI -> ; [86:41]
    |       |       `--RCURLY -> } [87:8]
    |       `--RCURLY -> } [88:4]
    |--RECORD_DEF -> RECORD_DEF [91:4]
    |   |--MODIFIERS -> MODIFIERS [91:4]
    |   |   `--LITERAL_PUBLIC -> public [91:4]
    |   |--LITERAL_RECORD -> record [91:11]
    |   |--IDENT -> OtherThing [91:18]
    |   |--LPAREN -> ( [91:28]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [91:29]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [91:29]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [91:29]
    |   |   |   |--TYPE -> TYPE [91:29]
    |   |   |   |   `--IDENT -> String [91:29]
    |   |   |   `--IDENT -> name [91:36]
    |   |   |--COMMA -> , [91:40]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [91:42]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [91:42]
    |   |       |--TYPE -> TYPE [91:42]
    |   |       |   `--IDENT -> String [91:42]
    |   |       `--IDENT -> address [91:49]
    |   |--RPAREN -> ) [91:56]
    |   `--OBJBLOCK -> OBJBLOCK [91:58]
    |       |--LCURLY -> { [91:58]
    |       |--CTOR_DEF -> CTOR_DEF [92:8]
    |       |   |--MODIFIERS -> MODIFIERS [92:8]
    |       |   |   `--LITERAL_PUBLIC -> public [92:8]
    |       |   |--IDENT -> OtherThing [92:15]
    |       |   |--LPAREN -> ( [92:25]
    |       |   |--PARAMETERS -> PARAMETERS [92:26]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [92:26]
    |       |   |       |--MODIFIERS -> MODIFIERS [92:26]
    |       |   |       |--TYPE -> TYPE [92:26]
    |       |   |       |   `--IDENT -> String [92:26]
    |       |   |       `--IDENT -> name [92:33]
    |       |   |--RPAREN -> ) [92:37]
    |       |   `--SLIST -> { [92:39]
    |       |       |--CTOR_CALL -> this [93:12]
    |       |       |   |--LPAREN -> ( [93:16]
    |       |       |   |--ELIST -> ELIST [93:17]
    |       |       |   |   |--EXPR -> EXPR [93:17]
    |       |       |   |   |   `--IDENT -> name [93:17]
    |       |       |   |   |--COMMA -> , [93:21]
    |       |       |   |   `--EXPR -> EXPR [93:23]
    |       |       |   |       `--STRING_LITERAL -> "Unknown" [93:23]
    |       |       |   |--RPAREN -> ) [93:32]
    |       |       |   `--SEMI -> ; [93:33]
    |       |       `--RCURLY -> } [94:8]
    |       `--RCURLY -> } [95:4]
    |--RECORD_DEF -> RECORD_DEF [97:4]
    |   |--MODIFIERS -> MODIFIERS [97:4]
    |   |   `--LITERAL_PUBLIC -> public [97:4]
    |   |--LITERAL_RECORD -> record [97:11]
    |   |--IDENT -> Thing2 [97:18]
    |   |--LPAREN -> ( [97:24]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [97:25]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [97:25]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [97:25]
    |   |   |   |--TYPE -> TYPE [97:25]
    |   |   |   |   `--IDENT -> String [97:25]
    |   |   |   `--IDENT -> name [97:32]
    |   |   |--COMMA -> , [97:36]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [97:38]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [97:38]
    |   |       |--TYPE -> TYPE [97:38]
    |   |       |   `--IDENT -> String [97:38]
    |   |       `--IDENT -> address [97:45]
    |   |--RPAREN -> ) [97:52]
    |   `--OBJBLOCK -> OBJBLOCK [97:54]
    |       |--LCURLY -> { [97:54]
    |       |--CTOR_DEF -> CTOR_DEF [98:8]
    |       |   |--MODIFIERS -> MODIFIERS [98:8]
    |       |   |   `--LITERAL_PUBLIC -> public [98:8]
    |       |   |--IDENT -> Thing2 [98:15]
    |       |   |--LPAREN -> ( [98:21]
    |       |   |--PARAMETERS -> PARAMETERS [98:22]
    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [98:22]
    |       |   |   |   |--MODIFIERS -> MODIFIERS [98:22]
    |       |   |   |   |--TYPE -> TYPE [98:22]
    |       |   |   |   |   `--IDENT -> String [98:22]
    |       |   |   |   `--IDENT -> name [98:29]
    |       |   |   |--COMMA -> , [98:33]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [98:35]
    |       |   |       |--MODIFIERS -> MODIFIERS [98:35]
    |       |   |       |--TYPE -> TYPE [98:35]
    |       |   |       |   `--IDENT -> String [98:35]
    |       |   |       `--IDENT -> address [98:42]
    |       |   |--RPAREN -> ) [98:49]
    |       |   `--SLIST -> { [98:51]
    |       |       |--EXPR -> EXPR [99:22]
    |       |       |   `--ASSIGN -> = [99:22]
    |       |       |       |--DOT -> . [99:16]
    |       |       |       |   |--LITERAL_THIS -> this [99:12]
    |       |       |       |   `--IDENT -> name [99:17]
    |       |       |       `--IDENT -> name [99:24]
    |       |       |--SEMI -> ; [99:28]
    |       |       |--EXPR -> EXPR [100:25]
    |       |       |   `--ASSIGN -> = [100:25]
    |       |       |       |--DOT -> . [100:16]
    |       |       |       |   |--LITERAL_THIS -> this [100:12]
    |       |       |       |   `--IDENT -> address [100:17]
    |       |       |       `--IDENT -> address [100:27]
    |       |       |--SEMI -> ; [100:34]
    |       |       `--RCURLY -> } [101:8]
    |       `--RCURLY -> } [102:4]
    |--RECORD_DEF -> RECORD_DEF [104:4]
    |   |--MODIFIERS -> MODIFIERS [104:4]
    |   |   `--LITERAL_PUBLIC -> public [104:4]
    |   |--LITERAL_RECORD -> record [104:11]
    |   |--IDENT -> Tricky [104:18]
    |   |--LPAREN -> ( [104:24]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [104:25]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [104:25]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [104:25]
    |   |       |--TYPE -> TYPE [104:25]
    |   |       |   `--LITERAL_INT -> int [104:25]
    |   |       `--IDENT -> record [104:29]
    |   |--RPAREN -> ) [104:35]
    |   `--OBJBLOCK -> OBJBLOCK [104:37]
    |       |--LCURLY -> { [104:37]
    |       `--RCURLY -> } [104:38]
    |--RECORD_DEF -> RECORD_DEF [107:4]
    |   |--MODIFIERS -> MODIFIERS [107:4]
    |   |   `--LITERAL_PUBLIC -> public [107:4]
    |   |--LITERAL_RECORD -> record [107:11]
    |   |--IDENT -> UnknownRecord [107:18]
    |   |--LPAREN -> ( [107:31]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [107:32]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [107:32]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [107:32]
    |   |   |   |--TYPE -> TYPE [107:32]
    |   |   |   |   `--IDENT -> String [107:32]
    |   |   |   `--IDENT -> known [107:39]
    |   |   |--COMMA -> , [107:44]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [107:46]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [107:46]
    |   |       |--TYPE -> TYPE [107:46]
    |   |       |   `--IDENT -> String [107:46]
    |   |       `--IDENT -> unknown [107:53]
    |   |--RPAREN -> ) [107:60]
    |   `--OBJBLOCK -> OBJBLOCK [107:62]
    |       |--LCURLY -> { [107:62]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [108:8]
    |       |   |--MODIFIERS -> MODIFIERS [108:8]
    |       |   |   |--LITERAL_PRIVATE -> private [108:8]
    |       |   |   |--LITERAL_STATIC -> static [108:16]
    |       |   |   `--FINAL -> final [108:23]
    |       |   |--TYPE -> TYPE [108:29]
    |       |   |   `--IDENT -> String [108:29]
    |       |   |--IDENT -> UNKNOWN [108:36]
    |       |   |--ASSIGN -> = [108:44]
    |       |   |   `--EXPR -> EXPR [108:46]
    |       |   |       `--STRING_LITERAL -> "Unknown" [108:46]
    |       |   `--SEMI -> ; [108:55]
    |       `--RCURLY -> } [109:4]
    |--RECORD_DEF -> RECORD_DEF [111:4]
    |   |--MODIFIERS -> MODIFIERS [111:4]
    |   |   `--LITERAL_PUBLIC -> public [111:4]
    |   |--LITERAL_RECORD -> record [111:11]
    |   |--IDENT -> Person [111:18]
    |   |--LPAREN -> ( [111:24]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [111:25]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [111:25]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [111:25]
    |   |   |   |--TYPE -> TYPE [111:25]
    |   |   |   |   `--IDENT -> String [111:25]
    |   |   |   `--IDENT -> name [111:32]
    |   |   |--COMMA -> , [111:36]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [111:38]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [111:38]
    |   |       |--TYPE -> TYPE [111:38]
    |   |       |   `--IDENT -> String [111:38]
    |   |       `--IDENT -> address [111:45]
    |   |--RPAREN -> ) [111:52]
    |   `--OBJBLOCK -> OBJBLOCK [111:54]
    |       |--LCURLY -> { [111:54]
    |       |--METHOD_DEF -> METHOD_DEF [112:8]
    |       |   |--MODIFIERS -> MODIFIERS [112:8]
    |       |   |   |--LITERAL_PUBLIC -> public [112:8]
    |       |   |   `--LITERAL_STATIC -> static [112:15]
    |       |   |--TYPE -> TYPE [112:22]
    |       |   |   `--IDENT -> Person [112:22]
    |       |   |--IDENT -> unnamed [112:29]
    |       |   |--LPAREN -> ( [112:36]
    |       |   |--PARAMETERS -> PARAMETERS [112:37]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [112:37]
    |       |   |       |--MODIFIERS -> MODIFIERS [112:37]
    |       |   |       |--TYPE -> TYPE [112:37]
    |       |   |       |   `--IDENT -> String [112:37]
    |       |   |       `--IDENT -> address [112:44]
    |       |   |--RPAREN -> ) [112:51]
    |       |   `--SLIST -> { [112:53]
    |       |       |--LITERAL_RETURN -> return [113:12]
    |       |       |   |--EXPR -> EXPR [113:19]
    |       |       |   |   `--LITERAL_NEW -> new [113:19]
    |       |       |   |       |--IDENT -> Person [113:23]
    |       |       |   |       |--LPAREN -> ( [113:29]
    |       |       |   |       |--ELIST -> ELIST [113:30]
    |       |       |   |       |   |--EXPR -> EXPR [113:30]
    |       |       |   |       |   |   `--STRING_LITERAL -> "Unnamed" [113:30]
    |       |       |   |       |   |--COMMA -> , [113:39]
    |       |       |   |       |   `--EXPR -> EXPR [113:41]
    |       |       |   |       |       `--IDENT -> address [113:41]
    |       |       |   |       `--RPAREN -> ) [113:48]
    |       |       |   `--SEMI -> ; [113:49]
    |       |       `--RCURLY -> } [114:8]
    |       `--RCURLY -> } [115:4]
    |--RECORD_DEF -> RECORD_DEF [118:4]
    |   |--MODIFIERS -> MODIFIERS [118:4]
    |   |   `--LITERAL_PUBLIC -> public [118:4]
    |   |--LITERAL_RECORD -> record [118:11]
    |   |--IDENT -> FXOrder [118:18]
    |   |--LPAREN -> ( [118:25]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [118:26]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [118:26]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [118:26]
    |   |   |   |--TYPE -> TYPE [118:26]
    |   |   |   |   `--LITERAL_INT -> int [118:26]
    |   |   |   `--IDENT -> units [118:30]
    |   |   |--COMMA -> , [118:35]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [119:26]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [119:26]
    |   |   |   |--TYPE -> TYPE [119:26]
    |   |   |   |   `--IDENT -> String [119:26]
    |   |   |   `--IDENT -> side [119:33]
    |   |   |--COMMA -> , [119:37]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [120:26]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [120:26]
    |   |   |   |--TYPE -> TYPE [120:26]
    |   |   |   |   `--LITERAL_DOUBLE -> double [120:26]
    |   |   |   `--IDENT -> price [120:33]
    |   |   |--COMMA -> , [120:38]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [121:26]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [121:26]
    |   |   |   |--TYPE -> TYPE [121:26]
    |   |   |   |   `--IDENT -> LocalDateTime [121:26]
    |   |   |   `--IDENT -> sentAt [121:40]
    |   |   |--COMMA -> , [121:46]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [122:26]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [122:26]
    |   |       |--TYPE -> TYPE [122:26]
    |   |       |   `--LITERAL_INT -> int [122:26]
    |   |       `--IDENT -> ttl [122:30]
    |   |--RPAREN -> ) [122:33]
    |   `--OBJBLOCK -> OBJBLOCK [122:35]
    |       |--LCURLY -> { [122:35]
    |       |--COMPACT_CTOR_DEF -> COMPACT_CTOR_DEF [123:8]
    |       |   |--MODIFIERS -> MODIFIERS [123:8]
    |       |   |   `--LITERAL_PUBLIC -> public [123:8]
    |       |   |--IDENT -> FXOrder [123:15]
    |       |   `--SLIST -> { [123:23]
    |       |       |--LITERAL_IF -> if [124:12]
    |       |       |   |--LPAREN -> ( [124:15]
    |       |       |   |--EXPR -> EXPR [124:22]
    |       |       |   |   `--LT -> < [124:22]
    |       |       |   |       |--IDENT -> units [124:16]
    |       |       |   |       `--NUM_INT -> 1 [124:24]
    |       |       |   |--RPAREN -> ) [124:25]
    |       |       |   `--SLIST -> { [124:27]
    |       |       |       |--LITERAL_THROW -> throw [125:16]
    |       |       |       |   |--EXPR -> EXPR [125:22]
    |       |       |       |   |   `--LITERAL_NEW -> new [125:22]
    |       |       |       |   |       |--IDENT -> IllegalArgumentException [125:26]
    |       |       |       |   |       |--LPAREN -> ( [125:50]
    |       |       |       |   |       |--ELIST -> ELIST [126:24]
    |       |       |       |   |       |   `--EXPR -> EXPR [126:24]
    |       |       |       |   |       |       `--STRING_LITERAL -> "FXOrder units must be positive" [126:24]
    |       |       |       |   |       `--RPAREN -> ) [126:56]
    |       |       |       |   `--SEMI -> ; [126:57]
    |       |       |       `--RCURLY -> } [127:12]
    |       |       |--LITERAL_IF -> if [128:12]
    |       |       |   |--LPAREN -> ( [128:15]
    |       |       |   |--EXPR -> EXPR [128:20]
    |       |       |   |   `--LT -> < [128:20]
    |       |       |   |       |--IDENT -> ttl [128:16]
    |       |       |   |       `--NUM_INT -> 0 [128:22]
    |       |       |   |--RPAREN -> ) [128:23]
    |       |       |   `--SLIST -> { [128:25]
    |       |       |       |--LITERAL_THROW -> throw [129:16]
    |       |       |       |   |--EXPR -> EXPR [129:22]
    |       |       |       |   |   `--LITERAL_NEW -> new [129:22]
    |       |       |       |   |       |--IDENT -> IllegalArgumentException [129:26]
    |       |       |       |   |       |--LPAREN -> ( [129:50]
    |       |       |       |   |       |--ELIST -> ELIST [130:24]
    |       |       |       |   |       |   `--EXPR -> EXPR [130:24]
    |       |       |       |   |       |       `--STRING_LITERAL -> "FXOrder TTL must be positive, or 0 for market orders" [130:24]
    |       |       |       |   |       `--RPAREN -> ) [130:78]
    |       |       |       |   `--SEMI -> ; [130:79]
    |       |       |       `--RCURLY -> } [131:12]
    |       |       |--LITERAL_IF -> if [132:12]
    |       |       |   |--LPAREN -> ( [132:15]
    |       |       |   |--EXPR -> EXPR [132:22]
    |       |       |   |   `--LE -> <= [132:22]
    |       |       |   |       |--IDENT -> price [132:16]
    |       |       |   |       `--NUM_FLOAT -> 0.0 [132:25]
    |       |       |   |--RPAREN -> ) [132:28]
    |       |       |   `--SLIST -> { [132:30]
    |       |       |       |--LITERAL_THROW -> throw [133:16]
    |       |       |       |   |--EXPR -> EXPR [133:22]
    |       |       |       |   |   `--LITERAL_NEW -> new [133:22]
    |       |       |       |   |       |--IDENT -> IllegalArgumentException [133:26]
    |       |       |       |   |       |--LPAREN -> ( [133:50]
    |       |       |       |   |       |--ELIST -> ELIST [134:24]
    |       |       |       |   |       |   `--EXPR -> EXPR [134:24]
    |       |       |       |   |       |       `--STRING_LITERAL -> "FXOrder price must be positive" [134:24]
    |       |       |       |   |       `--RPAREN -> ) [134:56]
    |       |       |       |   `--SEMI -> ; [134:57]
    |       |       |       `--RCURLY -> } [135:12]
    |       |       `--RCURLY -> } [136:8]
    |       `--RCURLY -> } [137:4]
    |--METHOD_DEF -> METHOD_DEF [138:4]
    |   |--MODIFIERS -> MODIFIERS [138:4]
    |   |   `--LITERAL_PUBLIC -> public [138:4]
    |   |--TYPE -> TYPE [138:11]
    |   |   `--LITERAL_BOOLEAN -> boolean [138:11]
    |   |--IDENT -> isLoggable [138:19]
    |   |--LPAREN -> ( [138:29]
    |   |--PARAMETERS -> PARAMETERS [138:30]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [138:30]
    |   |       |--MODIFIERS -> MODIFIERS [138:30]
    |   |       |--TYPE -> TYPE [138:30]
    |   |       |   `--IDENT -> LogRecord [138:30]
    |   |       `--IDENT -> record [138:40]
    |   |--RPAREN -> ) [138:46]
    |   `--SLIST -> { [138:48]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [139:8]
    |       |   |--MODIFIERS -> MODIFIERS [139:8]
    |       |   |--TYPE -> TYPE [139:8]
    |       |   |   `--IDENT -> String [139:8]
    |       |   |--IDENT -> packageName [139:15]
    |       |   `--ASSIGN -> = [139:27]
    |       |       `--EXPR -> EXPR [139:29]
    |       |           `--LITERAL_NULL -> null [139:29]
    |       |--SEMI -> ; [139:33]
    |       |--LITERAL_RETURN -> return [140:8]
    |       |   |--EXPR -> EXPR [140:48]
    |       |   |   `--METHOD_CALL -> ( [140:48]
    |       |   |       |--DOT -> . [140:37]
    |       |   |       |   |--METHOD_CALL -> ( [140:35]
    |       |   |       |   |   |--DOT -> . [140:21]
    |       |   |       |   |   |   |--IDENT -> record [140:15]
    |       |   |       |   |   |   `--IDENT -> getLoggerName [140:22]
    |       |   |       |   |   |--ELIST -> ELIST [140:36]
    |       |   |       |   |   `--RPAREN -> ) [140:36]
    |       |   |       |   `--IDENT -> startsWith [140:38]
    |       |   |       |--ELIST -> ELIST [140:49]
    |       |   |       |   `--EXPR -> EXPR [140:49]
    |       |   |       |       `--IDENT -> packageName [140:49]
    |       |   |       `--RPAREN -> ) [140:60]
    |       |   `--SEMI -> ; [140:61]
    |       `--RCURLY -> } [141:4]
    |--METHOD_DEF -> METHOD_DEF [143:4]
    |   |--MODIFIERS -> MODIFIERS [143:4]
    |   |   |--LITERAL_PRIVATE -> private [143:4]
    |   |   `--LITERAL_STATIC -> static [143:12]
    |   |--TYPE -> TYPE [143:19]
    |   |   `--LITERAL_VOID -> void [143:19]
    |   |--IDENT -> assertEquals [143:24]
    |   |--LPAREN -> ( [143:36]
    |   |--PARAMETERS -> PARAMETERS [143:37]
    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [143:37]
    |   |   |   |--MODIFIERS -> MODIFIERS [143:37]
    |   |   |   |--TYPE -> TYPE [143:37]
    |   |   |   |   `--IDENT -> Level [143:37]
    |   |   |   `--IDENT -> info [143:43]
    |   |   |--COMMA -> , [143:47]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [143:49]
    |   |       |--MODIFIERS -> MODIFIERS [143:49]
    |   |       |--TYPE -> TYPE [143:49]
    |   |       |   `--IDENT -> Level [143:49]
    |   |       `--IDENT -> level [143:55]
    |   |--RPAREN -> ) [143:60]
    |   `--SLIST -> { [143:62]
    |       `--RCURLY -> } [144:4]
    |--METHOD_DEF -> METHOD_DEF [146:4]
    |   |--MODIFIERS -> MODIFIERS [146:4]
    |   |   |--LITERAL_PRIVATE -> private [146:4]
    |   |   `--LITERAL_STATIC -> static [146:12]
    |   |--TYPE -> TYPE [146:19]
    |   |   `--LITERAL_VOID -> void [146:19]
    |   |--IDENT -> record [146:24]
    |   |--LPAREN -> ( [146:30]
    |   |--PARAMETERS -> PARAMETERS [146:31]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [146:31]
    |   |       |--MODIFIERS -> MODIFIERS [146:31]
    |   |       |--TYPE -> TYPE [146:31]
    |   |       |   `--IDENT -> LogRecord [146:31]
    |   |       |--ELLIPSIS -> ... [146:40]
    |   |       `--IDENT -> logArray [146:44]
    |   |--RPAREN -> ) [146:52]
    |   `--SLIST -> { [146:54]
    |       |--LITERAL_FOR -> for [147:8]
    |       |   |--LPAREN -> ( [147:12]
    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [147:13]
    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [147:13]
    |       |   |   |   |--MODIFIERS -> MODIFIERS [147:13]
    |       |   |   |   |--TYPE -> TYPE [147:13]
    |       |   |   |   |   `--IDENT -> LogRecord [147:13]
    |       |   |   |   `--IDENT -> record [147:23]
    |       |   |   |--COLON -> : [147:30]
    |       |   |   `--EXPR -> EXPR [147:32]
    |       |   |       `--IDENT -> logArray [147:32]
    |       |   |--RPAREN -> ) [147:40]
    |       |   `--SLIST -> { [147:42]
    |       |       |--EXPR -> EXPR [148:27]
    |       |       |   `--METHOD_CALL -> ( [148:27]
    |       |       |       |--DOT -> . [148:18]
    |       |       |       |   |--IDENT -> record [148:12]
    |       |       |       |   `--IDENT -> getLevel [148:19]
    |       |       |       |--ELIST -> ELIST [148:28]
    |       |       |       `--RPAREN -> ) [148:28]
    |       |       |--SEMI -> ; [148:29]
    |       |       `--RCURLY -> } [149:8]
    |       `--RCURLY -> } [150:4]
    |--METHOD_DEF -> METHOD_DEF [152:4]
    |   |--MODIFIERS -> MODIFIERS [152:4]
    |   |   |--LITERAL_PRIVATE -> private [152:4]
    |   |   `--LITERAL_STATIC -> static [152:12]
    |   |--TYPE -> TYPE [152:19]
    |   |   `--LITERAL_VOID -> void [152:19]
    |   |--IDENT -> checkRecord [152:24]
    |   |--LPAREN -> ( [152:35]
    |   |--PARAMETERS -> PARAMETERS [152:36]
    |   |--RPAREN -> ) [152:36]
    |   `--SLIST -> { [152:38]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [153:8]
    |       |   |--MODIFIERS -> MODIFIERS [153:8]
    |       |   |--TYPE -> TYPE [153:8]
    |       |   |   `--IDENT -> LogRecord [153:8]
    |       |   `--IDENT -> record [153:18]
    |       |--SEMI -> ; [153:24]
    |       |--EXPR -> EXPR [154:15]
    |       |   `--ASSIGN -> = [154:15]
    |       |       |--IDENT -> record [154:8]
    |       |       `--LITERAL_NEW -> new [154:17]
    |       |           |--IDENT -> LogRecord [154:21]
    |       |           |--LPAREN -> ( [154:30]
    |       |           |--ELIST -> ELIST [154:36]
    |       |           |   |--EXPR -> EXPR [154:36]
    |       |           |   |   `--DOT -> . [154:36]
    |       |           |   |       |--IDENT -> Level [154:31]
    |       |           |   |       `--IDENT -> ALL [154:37]
    |       |           |   |--COMMA -> , [154:40]
    |       |           |   `--EXPR -> EXPR [154:42]
    |       |           |       `--STRING_LITERAL -> "abc" [154:42]
    |       |           `--RPAREN -> ) [154:47]
    |       |--SEMI -> ; [154:48]
    |       |--EXPR -> EXPR [155:20]
    |       |   `--METHOD_CALL -> ( [155:20]
    |       |       |--IDENT -> assertEquals [155:8]
    |       |       |--ELIST -> ELIST [155:26]
    |       |       |   |--EXPR -> EXPR [155:26]
    |       |       |   |   `--DOT -> . [155:26]
    |       |       |   |       |--IDENT -> Level [155:21]
    |       |       |   |       `--IDENT -> INFO [155:27]
    |       |       |   |--COMMA -> , [155:31]
    |       |       |   `--EXPR -> EXPR [155:48]
    |       |       |       `--METHOD_CALL -> ( [155:48]
    |       |       |           |--DOT -> . [155:39]
    |       |       |           |   |--IDENT -> record [155:33]
    |       |       |           |   `--IDENT -> getLevel [155:40]
    |       |       |           |--ELIST -> ELIST [155:49]
    |       |       |           `--RPAREN -> ) [155:49]
    |       |       `--RPAREN -> ) [155:50]
    |       |--SEMI -> ; [155:51]
    |       `--RCURLY -> } [156:4]
    |--RECORD_DEF -> RECORD_DEF [158:4]
    |   |--MODIFIERS -> MODIFIERS [158:4]
    |   |--LITERAL_RECORD -> record [158:4]
    |   |--IDENT -> NoComps [158:11]
    |   |--LPAREN -> ( [158:18]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [158:19]
    |   |--RPAREN -> ) [158:19]
    |   `--OBJBLOCK -> OBJBLOCK [158:21]
    |       |--LCURLY -> { [158:21]
    |       `--RCURLY -> } [158:22]
    |--RECORD_DEF -> RECORD_DEF [159:4]
    |   |--MODIFIERS -> MODIFIERS [159:4]
    |   |--LITERAL_RECORD -> record [159:4]
    |   |--IDENT -> Record [159:11]
    |   |--LPAREN -> ( [159:17]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [159:18]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [159:18]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [159:18]
    |   |       |--TYPE -> TYPE [159:18]
    |   |       |   `--IDENT -> Record [159:18]
    |   |       `--IDENT -> record [159:25]
    |   |--RPAREN -> ) [159:31]
    |   `--OBJBLOCK -> OBJBLOCK [159:33]
    |       |--LCURLY -> { [159:33]
    |       `--RCURLY -> } [159:34]
    |--RECORD_DEF -> RECORD_DEF [161:4]
    |   |--MODIFIERS -> MODIFIERS [161:4]
    |   |--LITERAL_RECORD -> record [161:4]
    |   |--IDENT -> R5 [161:11]
    |   |--LPAREN -> ( [161:13]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [161:14]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [161:14]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [161:14]
    |   |       |--TYPE -> TYPE [161:14]
    |   |       |   `--IDENT -> String [161:14]
    |   |       |--ELLIPSIS -> ... [161:20]
    |   |       `--IDENT -> args [161:24]
    |   |--RPAREN -> ) [161:28]
    |   `--OBJBLOCK -> OBJBLOCK [161:30]
    |       |--LCURLY -> { [161:30]
    |       `--RCURLY -> } [161:31]
    |--RECORD_DEF -> RECORD_DEF [162:4]
    |   |--MODIFIERS -> MODIFIERS [162:4]
    |   |--LITERAL_RECORD -> record [162:4]
    |   |--IDENT -> R6 [162:11]
    |   |--IMPLEMENTS_CLAUSE -> implements [162:38]
    |   |   `--DOT -> . [162:56]
    |   |       |--DOT -> . [162:53]
    |   |       |   |--IDENT -> java [162:49]
    |   |       |   `--IDENT -> io [162:54]
    |   |       `--IDENT -> Serializable [162:57]
    |   |--LPAREN -> ( [162:13]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [162:14]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [162:14]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [162:14]
    |   |   |   |--TYPE -> TYPE [162:14]
    |   |   |   |   `--LITERAL_LONG -> long [162:14]
    |   |   |   `--IDENT -> l [162:19]
    |   |   |--COMMA -> , [162:20]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [162:22]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [162:22]
    |   |       |--TYPE -> TYPE [162:22]
    |   |       |   `--IDENT -> String [162:22]
    |   |       |--ELLIPSIS -> ... [162:28]
    |   |       `--IDENT -> args [162:32]
    |   |--RPAREN -> ) [162:36]
    |   `--OBJBLOCK -> OBJBLOCK [162:70]
    |       |--LCURLY -> { [162:70]
    |       `--RCURLY -> } [162:71]
    |--RECORD_DEF -> RECORD_DEF [163:4]
    |   |--MODIFIERS -> MODIFIERS [163:4]
    |   |--LITERAL_RECORD -> record [163:4]
    |   |--IDENT -> R7 [163:11]
    |   |--LPAREN -> ( [163:13]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [163:14]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [163:14]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [163:14]
    |   |   |   |--TYPE -> TYPE [163:14]
    |   |   |   |   `--IDENT -> String [163:14]
    |   |   |   `--IDENT -> s1 [163:21]
    |   |   |--COMMA -> , [163:23]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [163:25]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [163:25]
    |   |   |   |--TYPE -> TYPE [163:25]
    |   |   |   |   `--IDENT -> String [163:25]
    |   |   |   `--IDENT -> s2 [163:32]
    |   |   |--COMMA -> , [163:34]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [163:36]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [163:36]
    |   |       |--TYPE -> TYPE [163:36]
    |   |       |   `--IDENT -> String [163:36]
    |   |       |--ELLIPSIS -> ... [163:42]
    |   |       `--IDENT -> args [163:46]
    |   |--RPAREN -> ) [163:50]
    |   `--OBJBLOCK -> OBJBLOCK [163:52]
    |       |--LCURLY -> { [163:52]
    |       `--RCURLY -> } [163:53]
    |--RECORD_DEF -> RECORD_DEF [165:4]
    |   |--MODIFIERS -> MODIFIERS [165:4]
    |   |--LITERAL_RECORD -> record [165:4]
    |   |--IDENT -> RI [165:11]
    |   |--LPAREN -> ( [165:13]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [165:14]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [165:14]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [165:14]
    |   |       |--TYPE -> TYPE [165:14]
    |   |       |   `--LITERAL_INT -> int [165:14]
    |   |       |--ELLIPSIS -> ... [165:17]
    |   |       `--IDENT -> xs [165:21]
    |   |--RPAREN -> ) [165:23]
    |   `--OBJBLOCK -> OBJBLOCK [165:25]
    |       |--LCURLY -> { [165:25]
    |       `--RCURLY -> } [165:27]
    |--RECORD_DEF -> RECORD_DEF [166:4]
    |   |--MODIFIERS -> MODIFIERS [166:4]
    |   |--LITERAL_RECORD -> record [166:4]
    |   |--IDENT -> RII [166:11]
    |   |--LPAREN -> ( [166:14]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [166:15]
    |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [166:15]
    |   |   |   |--ANNOTATIONS -> ANNOTATIONS [166:15]
    |   |   |   |--TYPE -> TYPE [166:15]
    |   |   |   |   `--LITERAL_INT -> int [166:15]
    |   |   |   `--IDENT -> x [166:19]
    |   |   |--COMMA -> , [166:20]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [166:22]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [166:22]
    |   |       |--TYPE -> TYPE [166:22]
    |   |       |   `--LITERAL_INT -> int [166:22]
    |   |       |--ELLIPSIS -> ... [166:25]
    |   |       `--IDENT -> xs [166:29]
    |   |--RPAREN -> ) [166:31]
    |   `--OBJBLOCK -> OBJBLOCK [166:33]
    |       |--LCURLY -> { [166:33]
    |       `--RCURLY -> } [166:35]
    |--RECORD_DEF -> RECORD_DEF [167:4]
    |   |--MODIFIERS -> MODIFIERS [167:4]
    |   |--LITERAL_RECORD -> record [167:4]
    |   |--IDENT -> RX [167:11]
    |   |--LPAREN -> ( [167:13]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [167:17]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [167:17]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [167:17]
    |   |       |--TYPE -> TYPE [167:17]
    |   |       |   `--ARRAY_DECLARATOR -> [ [167:17]
    |   |       |       |--LITERAL_INT -> int [167:14]
    |   |       |       `--RBRACK -> ] [167:18]
    |   |       `--IDENT -> xs [167:20]
    |   |--RPAREN -> ) [167:22]
    |   `--OBJBLOCK -> OBJBLOCK [167:24]
    |       |--LCURLY -> { [167:24]
    |       `--RCURLY -> } [167:26]
    |--VARIABLE_DEF -> VARIABLE_DEF [169:4]
    |   |--MODIFIERS -> MODIFIERS [169:4]
    |   |   |--LITERAL_PRIVATE -> private [169:4]
    |   |   `--LITERAL_STATIC -> static [169:12]
    |   |--TYPE -> TYPE [169:19]
    |   |   `--LITERAL_INT -> int [169:19]
    |   |--IDENT -> record [169:23]
    |   |--ASSIGN -> = [169:30]
    |   |   `--EXPR -> EXPR [169:32]
    |   |       `--NUM_INT -> 2 [169:32]
    |   `--SEMI -> ; [169:33]
    |--METHOD_DEF -> METHOD_DEF [171:4]
    |   |--MODIFIERS -> MODIFIERS [171:4]
    |   |   `--LITERAL_PUBLIC -> public [171:4]
    |   |--TYPE -> TYPE [171:11]
    |   |   |--IDENT -> Class [171:11]
    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [171:16]
    |   |       |--GENERIC_START -> < [171:16]
    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [171:23]
    |   |       |   `--ARRAY_DECLARATOR -> [ [171:23]
    |   |       |       |--IDENT -> Record [171:17]
    |   |       |       `--RBRACK -> ] [171:24]
    |   |       `--GENERIC_END -> > [171:25]
    |   |--IDENT -> getRecordType [171:27]
    |   |--LPAREN -> ( [171:40]
    |   |--PARAMETERS -> PARAMETERS [171:41]
    |   |--RPAREN -> ) [171:41]
    |   `--SLIST -> { [171:43]
    |       |--LITERAL_RETURN -> return [172:8]
    |       |   |--EXPR -> EXPR [172:23]
    |       |   |   `--DOT -> . [172:23]
    |       |   |       |--ARRAY_DECLARATOR -> [ [172:21]
    |       |   |       |   |--IDENT -> Record [172:15]
    |       |   |       |   `--RBRACK -> ] [172:22]
    |       |   |       `--LITERAL_CLASS -> class [172:24]
    |       |   `--SEMI -> ; [172:29]
    |       `--RCURLY -> } [173:4]
    |--CLASS_DEF -> CLASS_DEF [175:4]
    |   |--MODIFIERS -> MODIFIERS [175:4]
    |   |--LITERAL_CLASS -> class [175:4]
    |   |--IDENT -> LocalRecordHelper [175:10]
    |   `--OBJBLOCK -> OBJBLOCK [175:28]
    |       |--LCURLY -> { [175:28]
    |       |--METHOD_DEF -> METHOD_DEF [176:8]
    |       |   |--MODIFIERS -> MODIFIERS [176:8]
    |       |   |--TYPE -> TYPE [176:8]
    |       |   |   |--IDENT -> Class [176:8]
    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [176:13]
    |       |   |       |--GENERIC_START -> < [176:13]
    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [176:14]
    |       |   |       |   `--WILDCARD_TYPE -> ? [176:14]
    |       |   |       `--GENERIC_END -> > [176:15]
    |       |   |--IDENT -> m [176:17]
    |       |   |--LPAREN -> ( [176:18]
    |       |   |--PARAMETERS -> PARAMETERS [176:19]
    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [176:19]
    |       |   |       |--MODIFIERS -> MODIFIERS [176:19]
    |       |   |       |--TYPE -> TYPE [176:19]
    |       |   |       |   `--LITERAL_INT -> int [176:19]
    |       |   |       `--IDENT -> x [176:23]
    |       |   |--RPAREN -> ) [176:24]
    |       |   `--SLIST -> { [176:26]
    |       |       |--RECORD_DEF -> RECORD_DEF [177:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [177:12]
    |       |       |   |--LITERAL_RECORD -> record [177:12]
    |       |       |   |--IDENT -> R76 [177:19]
    |       |       |   |--LPAREN -> ( [177:23]
    |       |       |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [177:24]
    |       |       |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [177:24]
    |       |       |   |       |--ANNOTATIONS -> ANNOTATIONS [177:24]
    |       |       |   |       |--TYPE -> TYPE [177:24]
    |       |       |   |       |   `--LITERAL_INT -> int [177:24]
    |       |       |   |       `--IDENT -> x [177:28]
    |       |       |   |--RPAREN -> ) [177:29]
    |       |       |   `--OBJBLOCK -> OBJBLOCK [177:31]
    |       |       |       |--LCURLY -> { [177:31]
    |       |       |       `--RCURLY -> } [177:33]
    |       |       |--LITERAL_RETURN -> return [178:12]
    |       |       |   |--EXPR -> EXPR [178:20]
    |       |       |   |   `--DOT -> . [178:20]
    |       |       |   |       |--IDENT -> R [178:19]
    |       |       |   |       `--LITERAL_CLASS -> class [178:21]
    |       |       |   `--SEMI -> ; [178:26]
    |       |       `--RCURLY -> } [179:8]
    |       |--CLASS_DEF -> CLASS_DEF [181:8]
    |       |   |--MODIFIERS -> MODIFIERS [181:8]
    |       |   |   `--LITERAL_PRIVATE -> private [181:8]
    |       |   |--LITERAL_CLASS -> class [181:16]
    |       |   |--IDENT -> R [181:22]
    |       |   `--OBJBLOCK -> OBJBLOCK [181:24]
    |       |       |--LCURLY -> { [181:24]
    |       |       |--CTOR_DEF -> CTOR_DEF [182:12]
    |       |       |   |--MODIFIERS -> MODIFIERS [182:12]
    |       |       |   |   `--LITERAL_PUBLIC -> public [182:12]
    |       |       |   |--IDENT -> R [182:19]
    |       |       |   |--LPAREN -> ( [182:20]
    |       |       |   |--PARAMETERS -> PARAMETERS [182:21]
    |       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [182:21]
    |       |       |   |       |--MODIFIERS -> MODIFIERS [182:21]
    |       |       |   |       |--TYPE -> TYPE [182:21]
    |       |       |   |       |   `--LITERAL_INT -> int [182:21]
    |       |       |   |       `--IDENT -> x [182:25]
    |       |       |   |--RPAREN -> ) [182:26]
    |       |       |   `--SLIST -> { [182:28]
    |       |       |       `--RCURLY -> } [183:12]
    |       |       `--RCURLY -> } [184:8]
    |       `--RCURLY -> } [185:4]
    |--RECORD_DEF -> RECORD_DEF [187:4]
    |   |--MODIFIERS -> MODIFIERS [187:4]
    |   |--LITERAL_RECORD -> record [187:4]
    |   |--IDENT -> R1 [187:11]
    |   |--IMPLEMENTS_CLAUSE -> implements [187:17]
    |   |   `--IDENT -> Serializable [187:28]
    |   |--LPAREN -> ( [187:14]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [187:15]
    |   |--RPAREN -> ) [187:15]
    |   `--OBJBLOCK -> OBJBLOCK [187:41]
    |       |--LCURLY -> { [187:41]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [188:8]
    |       |   |--MODIFIERS -> MODIFIERS [188:8]
    |       |   |   |--LITERAL_PRIVATE -> private [188:8]
    |       |   |   |--LITERAL_STATIC -> static [188:16]
    |       |   |   `--FINAL -> final [188:23]
    |       |   |--TYPE -> TYPE [188:29]
    |       |   |   `--IDENT -> TimeUnit [188:29]
    |       |   |--IDENT -> Path [188:38]
    |       |   |--ASSIGN -> = [188:43]
    |       |   |   `--EXPR -> EXPR [188:45]
    |       |   |       `--LITERAL_NULL -> null [188:45]
    |       |   `--SEMI -> ; [188:49]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [189:8]
    |       |   |--MODIFIERS -> MODIFIERS [189:8]
    |       |   |   |--LITERAL_PRIVATE -> private [189:8]
    |       |   |   |--LITERAL_STATIC -> static [189:16]
    |       |   |   `--FINAL -> final [189:23]
    |       |   |--TYPE -> TYPE [189:29]
    |       |   |   `--LITERAL_LONG -> long [189:29]
    |       |   |--IDENT -> serialVersionUID [189:34]
    |       |   |--ASSIGN -> = [189:51]
    |       |   |   `--EXPR -> EXPR [189:53]
    |       |   |       `--UNARY_MINUS -> - [189:53]
    |       |   |           `--NUM_LONG -> 2911897846173867769L [189:54]
    |       |   `--SEMI -> ; [189:74]
    |       |--COMPACT_CTOR_DEF -> COMPACT_CTOR_DEF [191:8]
    |       |   |--MODIFIERS -> MODIFIERS [191:8]
    |       |   |   `--LITERAL_PUBLIC -> public [191:8]
    |       |   |--IDENT -> R1 [191:15]
    |       |   `--SLIST -> { [191:18]
    |       |       `--RCURLY -> } [193:8]
    |       `--RCURLY -> } [194:4]
    |--RECORD_DEF -> RECORD_DEF [196:4]
    |   |--MODIFIERS -> MODIFIERS [196:4]
    |   |--LITERAL_RECORD -> record [196:4]
    |   |--IDENT -> RR3 [196:11]
    |   |--IMPLEMENTS_CLAUSE -> implements [196:32]
    |   |   `--IDENT -> Serializable [196:43]
    |   |--LPAREN -> ( [196:15]
    |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [196:16]
    |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [196:16]
    |   |       |--ANNOTATIONS -> ANNOTATIONS [196:16]
    |   |       |--TYPE -> TYPE [196:16]
    |   |       |   `--IDENT -> String [196:16]
    |   |       |--ELLIPSIS -> ... [196:22]
    |   |       `--IDENT -> args [196:26]
    |   |--RPAREN -> ) [196:30]
    |   `--OBJBLOCK -> OBJBLOCK [196:56]
    |       |--LCURLY -> { [196:56]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [197:8]
    |       |   |--MODIFIERS -> MODIFIERS [197:8]
    |       |   |   |--LITERAL_PRIVATE -> private [197:8]
    |       |   |   |--LITERAL_STATIC -> static [197:16]
    |       |   |   `--FINAL -> final [197:23]
    |       |   |--TYPE -> TYPE [197:29]
    |       |   |   `--LITERAL_BOOLEAN -> boolean [197:29]
    |       |   |--IDENT -> firstDataSetCreated [197:37]
    |       |   |--ASSIGN -> = [197:57]
    |       |   |   `--EXPR -> EXPR [197:59]
    |       |   |       `--LITERAL_FALSE -> false [197:59]
    |       |   `--SEMI -> ; [197:64]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [198:8]
    |       |   |--MODIFIERS -> MODIFIERS [198:8]
    |       |   |   |--LITERAL_PRIVATE -> private [198:8]
    |       |   |   |--LITERAL_STATIC -> static [198:16]
    |       |   |   `--FINAL -> final [198:23]
    |       |   |--TYPE -> TYPE [198:29]
    |       |   |   `--LITERAL_LONG -> long [198:29]
    |       |   |--IDENT -> serialVersionUID [198:34]
    |       |   |--ASSIGN -> = [198:51]
    |       |   |   `--EXPR -> EXPR [198:53]
    |       |   |       `--UNARY_MINUS -> - [198:53]
    |       |   |           `--NUM_LONG -> 5626758281412733319L [198:54]
    |       |   `--SEMI -> ; [198:74]
    |       |--COMPACT_CTOR_DEF -> COMPACT_CTOR_DEF [200:8]
    |       |   |--MODIFIERS -> MODIFIERS [200:8]
    |       |   |   `--LITERAL_PUBLIC -> public [200:8]
    |       |   |--IDENT -> RR3 [200:15]
    |       |   `--SLIST -> { [200:19]
    |       |       |--LITERAL_IF -> if [201:12]
    |       |       |   |--LPAREN -> ( [201:15]
    |       |       |   |--EXPR -> EXPR [201:16]
    |       |       |   |   `--IDENT -> firstDataSetCreated [201:16]
    |       |       |   |--RPAREN -> ) [201:35]
    |       |       |   `--SLIST -> { [201:37]
    |       |       |       |--EXPR -> EXPR [202:37]
    |       |       |       |   `--METHOD_CALL -> ( [202:37]
    |       |       |       |       |--DOT -> . [202:29]
    |       |       |       |       |   |--IDENT -> ProcessHandle [202:16]
    |       |       |       |       |   `--IDENT -> current [202:30]
    |       |       |       |       |--ELIST -> ELIST [202:38]
    |       |       |       |       `--RPAREN -> ) [202:38]
    |       |       |       |--SEMI -> ; [202:39]
    |       |       |       `--RCURLY -> } [203:12]
    |       |       `--RCURLY -> } [204:8]
    |       `--RCURLY -> } [205:4]
    |--METHOD_DEF -> METHOD_DEF [207:4]
    |   |--MODIFIERS -> MODIFIERS [207:4]
    |   |   |--LITERAL_PRIVATE -> private [207:4]
    |   |   `--LITERAL_STATIC -> static [207:12]
    |   |--TYPE -> TYPE [207:19]
    |   |   `--LITERAL_VOID -> void [207:19]
    |   |--IDENT -> recordArray [207:24]
    |   |--LPAREN -> ( [207:35]
    |   |--PARAMETERS -> PARAMETERS [207:40]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [207:40]
    |   |       |--MODIFIERS -> MODIFIERS [207:40]
    |   |       |--TYPE -> TYPE [207:40]
    |   |       |   `--ARRAY_DECLARATOR -> [ [207:40]
    |   |       |       |--LITERAL_INT -> int [207:36]
    |   |       |       `--RBRACK -> ] [207:41]
    |   |       `--IDENT -> record [207:43]
    |   |--RPAREN -> ) [207:49]
    |   `--SLIST -> { [207:51]
    |       |--EXPR -> EXPR [208:18]
    |       |   `--ASSIGN -> = [208:18]
    |       |       |--INDEX_OP -> [ [208:14]
    |       |       |   |--IDENT -> record [208:8]
    |       |       |   |--EXPR -> EXPR [208:15]
    |       |       |   |   `--NUM_INT -> 2 [208:15]
    |       |       |   `--RBRACK -> ] [208:16]
    |       |       `--DOT -> . [208:38]
    |       |           |--IDENT -> InputJava14Records [208:20]
    |       |           `--IDENT -> record [208:39]
    |       |--SEMI -> ; [208:45]
    |       `--RCURLY -> } [209:4]
    |--METHOD_DEF -> METHOD_DEF [211:4]
    |   |--MODIFIERS -> MODIFIERS [211:4]
    |   |   |--LITERAL_PUBLIC -> public [211:4]
    |   |   `--LITERAL_STATIC -> static [211:11]
    |   |--TYPE -> TYPE [211:18]
    |   |   `--LITERAL_VOID -> void [211:18]
    |   |--IDENT -> main [211:23]
    |   |--LPAREN -> ( [211:28]
    |   |--PARAMETERS -> PARAMETERS [211:29]
    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [211:29]
    |   |       |--MODIFIERS -> MODIFIERS [211:29]
    |   |       |--TYPE -> TYPE [211:29]
    |   |       |   `--IDENT -> String [211:29]
    |   |       |--ELLIPSIS -> ... [211:35]
    |   |       `--IDENT -> args [211:39]
    |   |--RPAREN -> ) [211:43]
    |   `--SLIST -> { [211:45]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [212:8]
    |       |   |--MODIFIERS -> MODIFIERS [212:8]
    |       |   |--TYPE -> TYPE [212:8]
    |       |   |   `--IDENT -> String [212:8]
    |       |   |--IDENT -> recordString [212:15]
    |       |   `--ASSIGN -> = [212:28]
    |       |       `--EXPR -> EXPR [212:30]
    |       |           `--STRING_LITERAL -> "record" [212:30]
    |       |--SEMI -> ; [212:38]
    |       |--EXPR -> EXPR [213:21]
    |       |   `--ASSIGN -> = [213:21]
    |       |       |--IDENT -> recordString [213:8]
    |       |       `--METHOD_CALL -> ( [213:45]
    |       |           |--DOT -> . [213:35]
    |       |           |   |--IDENT -> recordString [213:23]
    |       |           |   `--IDENT -> substring [213:36]
    |       |           |--ELIST -> ELIST [213:46]
    |       |           |   |--EXPR -> EXPR [213:46]
    |       |           |   |   `--IDENT -> record [213:46]
    |       |           |   |--COMMA -> , [213:52]
    |       |           |   `--EXPR -> EXPR [213:54]
    |       |           |       `--NUM_INT -> 5 [213:54]
    |       |           `--RPAREN -> ) [213:55]
    |       |--SEMI -> ; [213:56]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [214:8]
    |       |   |--MODIFIERS -> MODIFIERS [214:8]
    |       |   |--TYPE -> TYPE [214:8]
    |       |   |   `--IDENT -> Car [214:8]
    |       |   |--IDENT -> sedan [214:12]
    |       |   `--ASSIGN -> = [214:18]
    |       |       `--EXPR -> EXPR [214:20]
    |       |           `--LITERAL_NEW -> new [214:20]
    |       |               |--IDENT -> Car [214:24]
    |       |               |--LPAREN -> ( [214:27]
    |       |               |--ELIST -> ELIST [214:28]
    |       |               |   |--EXPR -> EXPR [214:28]
    |       |               |   |   `--STRING_LITERAL -> "rec" [214:28]
    |       |               |   |--COMMA -> , [214:33]
    |       |               |   `--EXPR -> EXPR [214:35]
    |       |               |       `--STRING_LITERAL -> "sedan" [214:35]
    |       |               `--RPAREN -> ) [214:42]
    |       |--SEMI -> ; [214:43]
    |       |--VARIABLE_DEF -> VARIABLE_DEF [215:8]
    |       |   |--MODIFIERS -> MODIFIERS [215:8]
    |       |   |--TYPE -> TYPE [215:8]
    |       |   |   `--IDENT -> String [215:8]
    |       |   |--IDENT -> s [215:15]
    |       |   `--ASSIGN -> = [215:17]
    |       |       `--EXPR -> EXPR [215:32]
    |       |           `--DOT -> . [215:32]
    |       |               |--IDENT -> UnknownRecord [215:19]
    |       |               `--IDENT -> UNKNOWN [215:33]
    |       |--SEMI -> ; [215:40]
    |       |--EXPR -> EXPR [216:22]
    |       |   `--METHOD_CALL -> ( [216:22]
    |       |       |--DOT -> . [216:14]
    |       |       |   |--IDENT -> Person [216:8]
    |       |       |   `--IDENT -> unnamed [216:15]
    |       |       |--ELIST -> ELIST [216:23]
    |       |       |   `--EXPR -> EXPR [216:23]
    |       |       |       `--STRING_LITERAL -> "100 Linda Ln." [216:23]
    |       |       `--RPAREN -> ) [216:38]
    |       |--SEMI -> ; [216:39]
    |       `--RCURLY -> } [217:4]
    `--RCURLY -> } [218:0]
