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