anchor.diff:  
   make_zerf2(OldEpochNum, Up, MajoritySize, MyName, AllMembers, OldWitness_list, MembersDict, S) ->
       try
  -        put(epochs, []),
           Epochs = lists:reverse(
                      lists:usort(
                        lists:flatten(
  
positive.code:                                           Proxy, private, ?TO*5),
                              [E || E <- Es]
                          end || FLU <- Up]))),
          put(epochs, Epochs),
          Relation = [],
          zerf_find_last_common(Epochs, Relation, MajoritySize, Up, S)
      catch
          throw:{zerf,no_common} ->
              case lists:usort(get(epochs)) of
                  [0] ->
                      %% Epoch 0 special case: make the "all" projection.
                      %% calc_projection2() will then filter out any FLUs that
                      %% aren't currently up to create the first chain.  If not
                      %% enough are up now, then it will fail to create a first
                      %% chain.
                      P = make_all_projection(MyName, AllMembers, OldWitness_list,
                                              MembersDict),
                      machi_projection:update_checksum(
                        P#projection_v1{epoch_number=OldEpochNum});
                  _Es ->
                      %% TODO: This corner case needs more thought.
                      %%
                      %% Easy case: epoch 1, All=[a,b,c], UPI=[a,b],
                      %%            Private by a is ok, then *all* crash.
                      %%            Upon restart, we see 'partial write' for
                      %%            epoch 1 but not unanimous.  Nobody can
                      %%            proceed because this case ends up getting
                      %%            stuck here.
                      %%
                      %% Hard case: Is it always true that *all* possible
                      %% private projections are not unanimous and therefore
                      %% the chain has never had a single stable configuration
                      %% and therefore we should act like the [epoch=0] case
                      %% above??  I don't believe that this is correct, but I
                      %% need to ponder more................
                      throw({zerf, {undecidable, _Es, Up}})
              end;
          _X:_Y ->
              throw({zerf, {damn_exception, Up, _X, _Y, erlang:get_stacktrace()}})
      after
          erase(epochs)
      end.
  
  zerf_find_last_common([], _Relation, _MajoritySize, _Up, _S) ->
      throw({zerf, no_common});
  zerf_find_last_common(UnsearchedEpochs, Relation, MajoritySize, Up, S) ->
      {NowEpochs, NextEpochs} = my_lists_split(5, UnsearchedEpochs),
  io:format(user, "zerf_find_last_common now_es ~p\n", [NowEpochs]),
      Rel2 = lists:foldl(
               fun({E, FLU}, Rel) ->
                       Proxy = proxy_pid(FLU, S),
                       case ?FLU_PC:read_projection(Proxy, private, E, ?TO) of
                           {ok, Proj} ->
  io:format(user, "fold ~p ~p ok\n", [E, FLU]),
                               %% Sort order: we want inner = bigger.
                               OorI = case inner_projection_exists(Proj) of
                                          true  -> z_inner;
  
negative.code:     ?REACT({a50, ?LINE, [{latest_epoch, P_latest#projection_v1.epoch_number},
                           {final_props, FinalProps}]}),
  %% io:format(user, "A50: ~p: ~W\n", [S#ch_mgr.name, get(react), 60]),
  %%if S#ch_mgr.name == a -> io:format(user, "A50: ~p: ~P\n", [S#ch_mgr.name, get(react), 60]); true -> ok end,
      {{no_change, FinalProps, P_latest#projection_v1.epoch_number}, S}.
  
  react_to_env_B10(Retries, P_newprop, P_latest, LatestUnanimousP,
  