anchor.diff:  
   extract_move({_Vb, [Src|_], [Dst|_]}) -> {Src, Dst}.
   
  -check_concurrent_backfills(-1 = _ConcurrentBackfills, _Node, _RunningB, Acc) ->
  +check_concurrent_moves(-1 = _ConcurrentMoves, _Node, _RunningB, Acc) ->
       Acc;
  -check_concurrent_backfills(_ConcurrentBackfills, _Node, [] = _RunningB, _Acc) ->
  +check_concurrent_moves(_ConcurrentMoves, _Node, [] = _RunningB, _Acc) ->
       true;
  -check_concurrent_backfills(ConcurrentBackfills, Node, [M | RestRunningB], Acc) ->
  +check_concurrent_moves(ConcurrentMoves, Node, [M | RestRunningB], Acc) ->
       {Src, Dst} = extract_move(M),
       case Src =:= Node orelse Dst =:= Node of
           true ->
  -            check_concurrent_backfills(ConcurrentBackfills-1, Node, RestRunningB, [M | Acc]);
  +            check_concurrent_moves(ConcurrentMoves-1, Node, RestRunningB, [M | Acc]);
           _ ->
  -            check_concurrent_backfills(ConcurrentBackfills, Node, RestRunningB, Acc)
  +            check_concurrent_moves(ConcurrentMoves, Node, RestRunningB, Acc)
       end.
   
   verify_starting_move(M, #vs{running_backfills = RunningB,
                               max_backfills_per_node = ConcurrentBackfills,
  +                            max_moves_per_node = ConcurrentMoves,
                               running_moves = RunningM,
                               running_compactions = RunningC}) ->
       miniassert(not lists:member(M, RunningM), "not in moves"),
  
positive.code: 
  -record(vs, { %% vs is verifier state
            max_backfills_per_node :: pos_integer(),
            moves_before_compaction :: pos_integer(),
            sched_state :: tuple(),
            all_performed_moves :: list(),
  
negative.code:                                                         BackfillsLimit, MovesBeforeCompaction,
                                                          MaxInflightMoves,
                                                          fun simulate_rebalance_log/2),
                           BackfillsLimit, MovesBeforeCompaction, MaxInflightMoves),
  
      R = lists:foldl(fun (_, R0) ->
                              {_, R1} = random:uniform_s(R0),
  