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