anchor.diff:                                                          BackfillsLimit, MovesBeforeCompaction,
                                                           MaxInflightMoves,
                                                           fun simulate_rebalance_log/2),
  -                         BackfillsLimit, MovesBeforeCompaction),
  +                         BackfillsLimit, MovesBeforeCompaction, MaxInflightMoves),
   
       R = lists:foldl(fun (_, R0) ->
                               {_, R1} = random:uniform_s(R0),
  
positive.code: 
  extract_move({_Vb, [Src|_], [Dst|_]}) -> {Src, Dst}.
  
  check_concurrent_backfills(-1 = _ConcurrentBackfills, _Node, _RunningB, Acc) ->
      Acc;
  check_concurrent_backfills(_ConcurrentBackfills, _Node, [] = _RunningB, _Acc) ->
      true;
  check_concurrent_backfills(ConcurrentBackfills, 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_backfills(ConcurrentBackfills, Node, RestRunningB, Acc)
      end.
  
  verify_starting_move(M, #vs{running_backfills = RunningB,
                              max_backfills_per_node = ConcurrentBackfills,
                              running_moves = RunningM,
                              running_compactions = RunningC}) ->
      miniassert(not lists:member(M, RunningM), "not in moves"),
  
negative.code:     {timeout, 120,
       maybe_parallel('4_to_3',
         [begin
              Title = lists:flatten(io_lib:format("4->3: replicas: ~p, vbuckets: ~p, limit: ~p, countdown: ~p, maxmoves: ~p, remove: ~p",
                                                  [R, VBs, L, C, M, Out])),
              Fun = fun () ->
                            test_rebalance(R, VBs, L, C, M, Nodes, lists:delete(Out, Nodes))
                    end,
              {timeout, 120, {Title, Fun}}
          end || R <- [1,0,3],
                 VBs <- [16, 4, 2, 256],
                 L <- [1,2],
                 C <- [1,2,3],
                 M <- [1,2,3],
                 Out <- Nodes,
                 maybe_filter_out_4_to_3(R, VBs, L, C, Out)])}.
  
  