anchor.diff:  check_repairs(Repairs) ->
       Check =
           fun(R=#repair{minus_one_xfer=MOX, plus_one_xfer=POX}, Repairs2) ->
  -                MOX2 = maybe_retry(R, R#repair.minus_one, MOX),
  -                POX2 = maybe_retry(R, R#repair.plus_one, POX),
  +                Pairs = R#repair.pairs,
  +                MO = get_minus_one(Pairs),
  +                PO = get_plus_one(Pairs),
  +                MOX2 = maybe_retry(R, MO, MOX),
  +                POX2 = maybe_retry(R, PO, POX),
  +
                   if ?XFER_COMPLETE(MOX2) andalso ?XFER_COMPLETE(POX2) ->
                           Repairs2;
                      true ->
  
positive.code: handle_call(get_tab, _From, State) ->
      {reply, ets:tab2list(State#state.idxtab), State};
  
  handle_call({repair, {Mod,Partition}=ModPartition, Pairs, FilterModFun},
              _From, State) ->
      #state{repairs=Repairs} = State,
  
      case get_repair(ModPartition, Repairs) of
          none ->
              [{MOP,_MOwner}=MinusOne, _, {POP,_POwner}=PlusOne] = Pairs,
              riak_core_handoff_manager:xfer(MinusOne, ModPartition,
                                             FilterModFun),
              riak_core_handoff_manager:xfer(PlusOne, ModPartition, FilterModFun),
              MOXStatus = #xfer_status{status=pending,
                                       mod_src_target={Mod, MOP, Partition}},
              POXStatus = #xfer_status{status=pending,
                                       mod_src_target={Mod, POP, Partition}},
  
              Repair = #repair{mod_partition=ModPartition,
                               filter_mod_fun=FilterModFun,
                               minus_one=MinusOne,
                               minus_one_xfer=MOXStatus,
                               plus_one=PlusOne,
                               plus_one_xfer=POXStatus},
              Repairs2 = Repairs ++ [Repair],
              State2 = State#state{repairs=Repairs2},
              lager:debug("add repair ~p", [ModPartition]),
              {reply, ok, State2};
          #repair{} ->
              {reply, ok, State}
      end;
  
  handle_call({repair_status, ModPartition}, _From, State) ->
  
negative.code:         {
            mod_partition         :: mod_partition(),
            filter_mod_fun        :: {module(), atom()},
            minus_one_xfer        :: xfer_status(),
            plus_one_xfer         :: xfer_status(),
            pairs                 :: [{index(), node()}]
          }).
  -type repair() :: #repair{}.
  -type repairs() :: [repair()].
  