Implement a fixed-capacity circular buffer (ring buffer) backed by a plain array, supporting push, pop, peek, isEmpty, isFull, and size — each in O(1) time. When pushing to a full buffer, use the **reject-on-full** policy: the push is refused and reports failure (the existing elements are preserved). Elements are dequeued in FIFO order (oldest first), and you must be able to iterate the current elements in logical order (oldest → newest). To make this runnable and gradable, implement a single function `solution(capacity, operations)` that simulates the buffer: - `capacity` — a positive integer, the fixed buffer size. - `operations` — a list of operations applied in order. Each operation is a list whose first element is the op name: - `['push', x]` → push `x`; append `True` if accepted, `False` if the buffer was full (reject policy). - `['pop']` → remove and return the oldest element; append `None` if the buffer is empty. - `['peek']` → return the oldest element without removing it; `None` if empty. - `['isEmpty']` → `True` if the buffer is empty. - `['isFull']` → `True` if the buffer is full. - `['size']` → the current number of elements. - `['toList']` → the current elements as a list in logical order (oldest → newest). Return the list of results, one entry per operation, in order. Use two indices (`head` for the oldest element and a `count`/`size`), computing the write position as `(head + count) % capacity`. This avoids the classic full-vs-empty ambiguity without sacrificing a slot. **Thread-safety extension (discussion):** wrap each operation in a mutex; for a *blocking* variant, use two condition variables — `not_full` (push waits on it while `count == capacity`, pop signals it) and `not_empty` (pop waits on it while `count == 0`, push signals it). Each op stays O(1) amortized; space is O(capacity).