A read-only memory wrapped so that the one extraction path can serve ROMs and RAMs alike.

How many words were non-zero at the end of `step`. Only diagnostics and tests want the exact number; the display wants `liveCountExceeds`.

Whether more than `limit` words were non-zero at the end of `step`. This is all the RAM table needs: it chooses between listing every non-zero location and a windowed display, and the exact figure never appears. Asking the cheaper question means the walk stops as soon as the answer is settled, and usually it never starts - a memory that has never had more than `limit` addresses written cannot have more than `limit` non-zero.

Build the store for one read/write memory. `window` is the simulation's `MaxArraySize`: the number of past steps that can still be asked about.

The four combinations the evaluators need, named as the `Memory1` versions they replace so that the call sites read the same.

Current contents at `addr`, on the bigint-value path. A store keeps values in one of two forms, chosen once by word width, and the caller has to ask for the one it holds - the evaluators do, via `BigIntState`. Asking for the other would otherwise read an array that was never filled, so it is redirected rather than trusted.

Current contents at `addr`, on the uint32 path. One array index in the dense case, which is the case every RAM a design can actually simulate falls into.

Put the memory back to the contents it was built with, discarding all history. Called when a simulation restarts, which is the one thing the old representation got wrong: it read the state left by the wrapped-out end of the previous run instead.

The whole memory as of `step`, as the immutable type the rest of Issie uses. Only for the places that genuinely want all of it - a memory diff, a golden file - never per render.

What one address held at the end of `step`.

Record a write, unless it changes nothing. A write of the value already at that address is not a write: skipping it costs one comparison on a value the reducer has already read (it is the old contents, which a RAM returns as its output) and saves an entry, which every later search and every later compaction then does not have to walk. Nothing observable changes - the contents are identical by definition, and the RAM table's read/write highlighting comes from the input step arrays rather than from here.