anchor.diff:    MultiReaderBytesRingBuffer ringBuffer2 = newInstance(nativeStore2, numReaders)
   ```
   
  -And once created, can be written to with `offer` (multiple threads can call `offer` at the "same" time). If
  -`offer` returns false it means that the queue is full and we are waiting for one or more readers.
  +When created, ot can be written to with `offer` (multiple threads can call `offer` at the same time). If `offer` returns `false` it means that the queue is full, and we are waiting for one or more readers.
   
   ```
     boolean succeeded = ringBuffer.offer(bytesToWrite);
   ```
   
  -And when `offer` has returned, the data is available for all readers to consume. The `read` method consumes from
  -the ring buffer into the passed `BytesStore` and returns a success boolean indicating whether anything was read.
  -If the queue is empty, false will be returned.
  +When `offer` has returned, the data is available for all readers to consume. The `read` method consumes from the ring buffer into the passed `BytesStore`, and returns a success boolean indicating whether anything was read. If the queue is empty, `false` will be returned.
   
   ```
     boolean succeeded = ringBuffer.read(bytesToRead);
  
positive.code: 
  ===== Writes and reads using ring buffer
  
  If both `writeBufferMode` and `readBufferMode` are set to `BufferMode.Asynchronous` then any writes to the
  queue will be given to the ring buffer and reads will read from the ring buffer. This gives the lowest possible
  latency as the disk subsystem is not involved at all. As with asynchronous writes, a background task is
  created in the builder's event loop to drain the ring buffer in to the underlying (disk-backed) chronicle queue.
  
  Example for asynchronous reads and writes using a memory-mapped file and two processes
  
  ```
      // process 1
  
negative.code: 
  === Chronicle Ring Buffer and Chronicle Queue
  
  There are two types of Chronicle Queue which are backed by the ring buffer:
  
  - `software.chronicle.enterprise.queue.RingBufferChronicleQueue`
  - `software.chronicle.enterprise.queue.EnterpriseSingleChronicleQueue`
  
  ==== software.chronicle.enterprise.queue.RingBufferChronicleQueue
  
  This queue does not implement the full contract of `ChronicleQueue`, and will throw a `UnsupportedOperationException`
  from some methods. It is created as in the example below, where:
  
  - `ringBuffer` is the ring buffer to back this queue with,
  - `wireType` is the wire type to use when appending and tailing,
  - `pauser` is the pauser to use by the appender when waiting for readers.
  
  ```
      ChronicleQueue rbq = new RingBufferChronicleQueue(ringBuffer, wireType, pauser);
  ```
  
  It can be used in the same way as any other Chronicle Queue implementation.
  
  ==== software.chronicle.enterprise.queue.EnterpriseSingleChronicleQueue
  
  The ring buffer can be used in one of two ways in EnterpriseSingleChronicleQueue, and this is controlled by
  the builder's `readBufferMode` and `writeBufferMode`.
  
  - Asynchronous writes
  - Writes and reads using ring buffer
  
  ===== Asynchronous writes
  
  If `writeBufferMode` is set to `BufferMode.Asynchronous` then any writes to the queue will be given to the ring buffer. A background task is created in the builder's event loop to drain the ring buffer in to the underlying (disk-backed) chronicle queue. Reads are made from the underlying queue. This use-case is designed to help with very "bursty" writes, which cannot afford to be blocked by a slow underlying disk sub-system. The ring buffer's buffer size must be carefully chosen to allow for the maxmimum burst size.
  
  ====== Example:
  
  ```
      try (ChronicleQueue queue = EnterpriseChronicleQueueBuilder
  