anchor.diff:      put(proxies_dict, orddict:new()),
       Add = fun(Name, Pid) -> put(proxies_dict, orddict:store(Name, Pid, get(proxies_dict))) end,
       OurFLUs = lists:usort([Src] ++ Repairing ++ UPI), % AP assumption!
  +    RepairMode = proplists:get_value(repair_mode, Opts, repair),
  +    Verb = proplists:get_value(verbose, Opts, true),
       Res = try
                 [begin
                      {ok, Proxy} = machi_proxy_flu1_client:start_link(P),
  
positive.code: 
                [ets:insert(ETS, {{directive_bytes, FLU}, 0}) || FLU <- OurFLUs],
                %% Repair files from perspective of Src, i.e. tail(UPI).
                RepairMode = proplists:get_value(repair_mode, Opts, repair),
                Verb = proplists:get_value(verbose, Opts, true),
                SrcProxy = orddict:fetch(Src, ProxiesDict),
                {ok, EpochID} = machi_proxy_flu1_client:get_epoch_id(
                                  SrcProxy, ?SHORT_TIMEOUT),
                Ds =
                    [{File, make_repair_directives(
                              ConsistencyMode, RepairMode, File, Size, EpochID,
                              Verb,
                              Src, OurFLUs, ProxiesDict, ETS)} ||
                        {File, {Size, _MissingList}} <- MissingFileSummary],
                %% TODO: for CP mode, any file missing from the Src FLU
                %% must be deleted on all repairing FLUs
                [begin
                     [{_, Bytes}] = ets:lookup(ETS, {directive_bytes, FLU}),
                     io:format(user, "Directive bytes for ~p: ~p\n", [FLU, Bytes])
                 end || FLU <- OurFLUs],
  
                ok = execute_repair_directives(ConsistencyMode, Ds, Src, EpochID,
                                               Verb, OurFLUs, ProxiesDict, ETS),
  
                todo_yo_not_quite_ok
            catch
  
negative.code: %% match, then we consider the two files in sync.  If there isn't a match,
  %% then we sort the lines and try another MD5, and if they match, then we're
  %% in sync.  In theory, that's lower overhead than the procedure used here.
  %%
  %% NOTE that one reason I chose the "directives list" method is to have an
  %% option, later, of choosing to repair a subset of repairee FLUs if there
  %% is a big discrepency between out of sync files: e.g., if FLU x has N
  %% bytes out of sync but FLU y has 50N bytes out of sync, then it's likely
  %% better to repair x only so that x can return to the UPI list quickly.
  %% Also, in the event that all repairees are roughly comparably out of sync,
  %% then the repair network traffic can be minimized by reading each chunk
  %% only once.
  
  make_repair_compare_fun(SrcFLU) ->
      fun({{Offset_X, _Sz_a, _Cs_a, FLU_a}, _N_a},
  