anchor.diff:                          true        -> S
                        end};
   handle_call({test_read_latest_public_projection, ReadRepairP}, _From, S) ->
  -    {Res, ExtraInfo, S2} = do_cl_read_latest_public_projection(ReadRepairP, S),
  -    {reply, {Res, ExtraInfo}, S2};
  +    {Perhaps, Val, ExtraInfo, S2} =
  +        do_cl_read_latest_public_projection(ReadRepairP, S),
  +    Res = {Perhaps, Val, ExtraInfo},
  +    {reply, Res, S2};
   handle_call(_Call, _From, S) ->
       {reply, whaaaaaaaaaa, S}.
   
  
positive.code:                                     #ch_mgr{proj=Proj1, myflu=MyFLU} = S) ->
      Epoch1 = Proj1#projection.epoch_number,
      case cl_read_latest_public_projection(S) of
          {unanimous, Proj2, Extra, S3} when Proj2 == Proj1 ->
              {Proj2, Extra, S3};
          {unanimous, #projection{epoch_number=Epoch2}=Proj2, Extra, _S3}
            when Epoch2 < Epoch1 orelse
                 (Epoch2 == Epoch1 andalso Proj2 /= Proj1) ->
              exit({invariant_error, mine, Proj1, cl_unanimous, Proj2, extra, Extra});
          {unanimous, #projection{epoch_number=Epoch2}=Proj2, Extra, S3}
            when Epoch2 > Epoch1 ->
              Proj2b = update_projection_dbg2(
                         Proj2, [{hooray, {date(), time()}}|Extra]),
              ok = machi_flu0:proj_write(MyFLU, Epoch2, private, Proj2b),
              {Proj2, Extra, S3#ch_mgr{proj=Proj2b}};
          {needs_work, FLUsRs, Extra, S3} ->
              if not ReadRepairP ->
                      {not_unanimous, [{results, FLUsRs}|Extra], S3};
                 true ->
                      {_Status, S4} = do_read_repair(FLUsRs, Extra, S3),
                      {not_unanimous, Extra, S4}
              end
      end.
  
  cl_read_latest_public_projection(#ch_mgr{proj=Proj}=S) ->
      #projection{all_members=All_list} = Proj,
      {_UpNodes, Partitions, S2} = calc_up_nodes(S),
      DoIt = fun(X) ->
                     case machi_flu0:proj_read_latest(X, public) of
  
negative.code: %% repeat do_cl_read_latest_public_projection() ??
  
  do_read_repair(FLUsRs, _Extra, #ch_mgr{proj=CurrentProj} = S) ->
      Unwrittens = [x || {_FLU, error_unwritten} <- FLUsRs],
      Ps = [Proj || {_FLU, Proj} <- FLUsRs, is_record(Proj, projection)],
      if Unwrittens == [] orelse Ps == [] ->
              {nothing_to_do, S};
         true ->
              %% We have at least one unwritten and also at least one proj.
              %% Pick the best one, then spam it everywhere.
  
              [{_Rank, BestProj}|_] = rank_and_sort_projections(Ps, CurrentProj),
              Epoch = BestProj#projection.epoch_number,
  
              %% We're doing repair, so use the flavor that will
              %% continue to all others even if there is an
              %% error_written on the local FLU.
              {_DontCare, _S2}=Res = cl_write_public_proj_skip_local_error(
                                                             Epoch, BestProj, S),
              Res
      end.
  
  