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