anchor.diff:  
   Furthermore, the threads must be able to send moves to each other,
   even if it's only to share the winning move.
  -This too, posed a challenge. _OptaPlanner is an Object Orientated constraint solver_,
  -so it's decision variables can be any valid Java type (not just booleans, numbers and floats), such as `Employee` or `Foo`.
  +This too, posed a challenge. _OptaPlanner is an Object Oriented constraint solver_,
  +so its decision variables can be any valid Java type (not just booleans, numbers and floats), such as `Employee` or `Foo`.
   Those variables can sit in any domain class (called planning entities), such as `Shift` or `Bar`.
   The move instances reference those class instances. When a solution gets cloned to initiate a move thread,
   those planning entities, such as `Shift` get cloned too.
  -So when a move from thread A gets send to thread B, OptaPlanner rebases the move on the solution state of thread B.
  +So when a move from thread A gets sent to thread B, OptaPlanner rebases the move on the solution state of thread B.
   This replaces the references from the move instance to thread A's solution state
   with the equivalent references of thread B's solution state. Pretty nifty.
   
  
positive.code: ** Doesn't do horizontal scaling on 1 dataset.
  
  * *Multi bet solving*: Solve one dataset in multiple ways, completely independent of each other. Take the best result.
  ** Works since the first OptaPlanner version
  ** It's usually a waste of resources: use the Benchmarker during development instead to find the best algorithm in advance.
  ** Doesn't scale horizontally: the best result is marginally better than a single-threaded result and takes equally long.
  
  
negative.code: 
  Let's take a look at the requirements for multithreaded incremental solving:
  
  * Horizontally scale an algorithm across CPUs.
  * Don't ruin the speedup of incremental score calculation.
  * Runs must be reproducible.
  
  
  === Horizontally scale an algorithm across CPUs
  
  There are several ways to use multiple threads without doing real multithreaded solving:
  
  