anchor.diff:          false -> latest_fact(L, FactA)
       end.
   
  -existing_leader(Replies, #fact{leader=undefined, views=Views}) ->
  +existing_leader(Replies, Abandoned, #fact{leader=undefined, views=Views}) ->
       Members = compute_members(Views),
  -    Counts = lists:foldl(fun({_, #fact{leader=Leader}}, Counts) ->
  -                                 case lists:member(Leader, Members) of
  +    Counts = lists:foldl(fun({_, #fact{epoch=Epoch, seq=Seq, leader=Leader}}, Counts) ->
  +                                 Vsn = {Epoch, Seq},
  +                                 Valid = (Abandoned =:= undefined) or (Vsn > Abandoned),
  +                                 case Valid andalso lists:member(Leader, Members) of
                                        true ->
  -                                         dict:update_counter(Leader, 1, Counts);
  +                                         dict:update_counter({Epoch, Leader}, 1, Counts);
                                        false ->
                                            Counts
                                    end
  
positive.code:     set_timer(?ENSEMBLE_TICK*2, follower_timeout, State).
  
  -spec following(_, state()) -> next_state().
  following(init, State) ->
      ?OUT("~p: Following: ~p~n", [State#state.id, leader(State)]),
      State2 = State#state{ready=false},
      State3 = reset_follower_timer(State2),
      {next_state, following, State3};
  following({commit, Fact, From}, State) ->
      State3 = case Fact#fact.epoch >= epoch(State) of
                   true ->
  
negative.code:     case Choices of
          [] ->
              undefined;
          [{{_, Leader}, _Count}|_] ->
              %% io:format("----~n~p~n~p~n-----~n", [Replies, Leader]),
              Leader
      end;
  existing_leader(_Replies, Abandoned, #fact{epoch=Epoch, seq=Seq, leader=Leader}) ->
      case {Epoch, Seq} > Abandoned of
          true ->
              Leader;
          false ->
              undefined
      end.
  
  -spec compute_members([[any()]]) -> [any()].
  compute_members(Views) ->
  