Design and implement an in-memory database that stores records by `key`. Each record is a map from `field` to integer `value`. Implement the following functionality. ### Basic operations - `set(key, field, value) -> None` - If `key` does not exist, create it. - Set `records[key][field] = value`. - `get(key, field) -> Optional[int]` - Return the value for `records[key][field]` if it exists. - Otherwise return `None`. - `delete(key, field) -> bool` - Delete `field` from `records[key]` if it exists and return `true`. - If the key or field does not exist, return `false`. - If deleting the field makes the record empty, remove the record. ### Operation counts and top keys For every operation that references a `key`, increment that key's operation count by `1`. This includes reads, writes, deletes, and user/lock operations that reference the key. Implement: - `topN(n) -> List[str]` - Return at most `n` keys sorted by operation count in descending order. - If two keys have the same operation count, sort them lexicographically ascending. - Return only keys that currently have an operation count. ### User locks Add user-aware modification operations and per-key locks. A key can be locked by at most one user at a time. - If a key is locked by user `u`, only user `u` may modify that key. - Other users may still call read-only operations such as `get`, but they cannot modify the locked key. - If a key is not locked, any user may modify it. Implement: - `setByUser(key, field, value, user) -> bool` - If `key` is unlocked or locked by `user`, set the field and return `true`. - If `key` is locked by another user, do not modify anything and return `false`. - `deleteByUser(key, field, user) -> bool` - If `key` is unlocked or locked by `user`, delete the field if it exists and return whether a field was deleted. - If `key` is locked by another user, do not modify anything and return `false`. - `lock(key, user) -> bool` - If `key` does not exist, return `false`. - If `key` is unlocked, lock it for `user` and return `true`. - If `key` is already locked, return `false`. - `unlock(key) -> bool` - If `key` is currently locked, remove the lock and return `true`. - If `key` is not locked, return `false`. Your implementation should support all operations efficiently and maintain correct operation counts for `topN`.