Design an in-memory banking system

Implement an in-memory banking system (e.g., in Java) that supports the following operations on user accounts. Assume user IDs are unique strings and monetary amounts are positive integers. Core requirements: 1) **Account creation and money movement** - `addUser(userId)`: create a new user/account. - `deposit(userId, amount)`: add funds to a user. - `transfer(fromUserId, toUserId, amount)`: move funds between users. - Define and handle error cases (unknown user, insufficient funds, invalid amount, etc.). 2) **Rank accounts by spending** - Provide a method like `getTopSpenders(k)` that returns the top `k` accounts ranked by their **total spending**. - Clearly define “spending” (e.g., total outgoing money via transfers and executed payments), and specify tie-breaking rules (e.g., by userId). - Aim for an efficient approach (a heap/priority queue is acceptable). 3) **Scheduled payments with cancellation** - `schedulePayment(fromUserId, toUserId, amount, executeAtTimestamp)` creates a future payment and returns a `paymentId`. - `cancelPayment(paymentId)` cancels a scheduled payment if it has not executed yet. - Provide a way to advance time / process due payments (e.g., `processPaymentsUpTo(timestamp)`), executing all payments whose execution time is reached. 4) **Merge users while preserving history** - `mergeUsers(sourceUserId, targetUserId)` merges `source` into `target`. - After merging, balances are combined, the source user no longer exists, and **payment/transfer history is preserved** in a sensible way (describe what the history contains and how it is represented after merge). - Define how scheduled payments involving the source user are handled after the merge. You may assume single-threaded execution unless otherwise specified. Design appropriate data structures and APIs, and ensure correctness for edge cases.