You are given an existing Java project for a general refactoring assessment. The project already contains model classes, comments, and unit tests, but several method bodies are missing. Implement the missing functionality without changing public method signatures. The goal is to pass all tests; clarity is useful, but correctness is the priority. Implement the variant assigned to you. ### Variant A: Reconstruct a Simple Route Implement: ```java List<String> buildRoute(List<Ticket> tickets, String start) ``` where each `Ticket` has: ```java String from; String to; ``` Rules: - Each ticket represents a directed trip from `from` to `to`. - Each ticket may be used at most once. - Return the ordered list of locations visited, including the starting location and every destination. - The returned route must start at `start` and use all tickets exactly once. - If `tickets` is empty, return a list containing only `start`. - If the input is invalid, throw `IllegalArgumentException`. Invalid cases include: - `tickets` is `null`. - `start` is `null` or blank. - A ticket is `null`, or its `from`/`to` value is `null` or blank. - Two tickets have the same `from` value, making the next step ambiguous. - The tickets cannot form one continuous route starting from `start` that uses every ticket exactly once. Example: ```text start = "SFO" tickets = [SFO -> LAX, LAX -> JFK, JFK -> BOS] return ["SFO", "LAX", "JFK", "BOS"] ``` ### Variant B: Implement a Versioned Multi-Level Key-Value Store Implement a class with the following public API: ```java class VersionedStore { void set(String recordKey, String fieldKey, String value, int timestamp); String get(String recordKey, String fieldKey, int timestamp); boolean delete(String recordKey, String fieldKey, int timestamp); List<String> scan(String recordKey, int timestamp); List<String> scanByPrefix(String recordKey, String prefix, int timestamp); } ``` The store has two key levels: `recordKey -> fieldKey -> versioned values`. Rules: - `set(recordKey, fieldKey, value, timestamp)` stores `value` for the given record and field at `timestamp`. - `get(recordKey, fieldKey, timestamp)` returns the latest value whose timestamp is less than or equal to the query timestamp. - If the field does not exist at that time, return `null`. - `delete(recordKey, fieldKey, timestamp)` records a deletion at `timestamp`. - Return `true` if the field existed immediately before this deletion timestamp. - Return `false` otherwise. - After deletion, queries at later timestamps should return `null` until the field is set again. - `scan(recordKey, timestamp)` returns all fields that exist in the record at `timestamp`, sorted lexicographically by `fieldKey`. - `scanByPrefix(recordKey, prefix, timestamp)` returns only existing fields whose `fieldKey` starts with `prefix`, also sorted lexicographically. - Scan results should be formatted as: ```text fieldKey(value) ``` Example: ```text set("user1", "name", "Ana", 1) set("user1", "city", "NYC", 2) get("user1", "name", 2) -> "Ana" scan("user1", 2) -> ["city(NYC)", "name(Ana)"] delete("user1", "name", 3) -> true get("user1", "name", 4) -> null set("user1", "name", "Ann", 5) get("user1", "name", 5) -> "Ann" ``` Assume update operation timestamps are positive integers and strictly increase across calls to `set` and `delete`. Query timestamps may be any positive integer.