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:        [begin
              Title = lists:flatten(
                        io_lib:format(
                          "11->13: replicas: ~p, vbuckets: ~p, limit: ~p, countdown: ~p, add: ~p",
                          [R, VBs, L, C, [In1, In2]])),
              Fun = fun () ->
                            Before = Nodes -- [In1, In2],
                            test_rebalance(R, VBs, L, C, C, Before, Nodes)
                    end,
              {timeout, 120, {Title, Fun}}
          end || R <- [1,0,2],
                 VBs <- [64, 256],
                 L <- [1,2],
                 C <- [2,3],
                 In1 <- Nodes,
                 In2 <- Nodes,
                 In1 =/= In2,
  
negative.code:           running_compactions :: list()
           }).
  
  prepare_verifier(SchedState, ConcurrentBackfills, MovesBeforeCompaction, MaxInflightMoves) ->
      #vs{max_backfills_per_node = ConcurrentBackfills,
          max_moves_per_node = MaxInflightMoves,
          moves_before_compaction = MovesBeforeCompaction,
          sched_state = SchedState,
          all_performed_moves = [],
  