anchor.diff:      Acc.
   
   pick_values(Ps, I) ->
  -    pick_values(Ps, 1, gb_trees:next(I), ordsets:new()).
  +    pick_values(Ps, 1, gb_trees:next(I), []).
   
   pick_values([H|T], H, {_, V, I}, Acc) ->
       pick_values(T, H+1, gb_trees:next(I), [V|Acc]);
  +pick_values([], _, _, Acc) ->
  +    Acc;
   pick_values(Ps, N, {_, _, I}, Acc) ->
  -    pick_values(Ps, N+1, gb_trees:next(I), Acc);
  -pick_values([], _, _, Acc) ->
  -    Acc.
  +    pick_values(Ps, N+1, gb_trees:next(I), Acc).
   
   has_been_seen(Key, Peers) ->
       case gb_trees:lookup(Key, Peers) of
           none ->
               false;
           {value, Peer} ->
  -            Peer#peer.last_seen =/= 0
  -    end.
  +            has_been_seen_(Peer)
  +    end.
  +
  +has_been_seen_(Peer) ->
  +    Peer#peer.last_seen =/= 0.
   
   ping_peer(Peer) ->
       %% Don't ping until our own HTTP endpoint is up. This is not strictly
  
positive.code:       pick_values(Ps, I)
      end.
  
  exclude_peer_uri(Uri, T, S) ->
      case lookup_peer(Uri, S) of
          none ->
  
negative.code: handle_cast({update_last_seen, Uri, Time}, State = #state{peers = Peers}) ->
      case is_local_uri(Uri, State) of
          false ->
              {NewPeers, ActualUri} =
                  case lookup_peer(Uri, State) of
                      none ->
                          %% can happen e.g. at first ping
                          Peer = start_ping_timer(
                                   fun set_max_retry/1,
                                   peer_record(Uri)),
                          {enter_peer(
                             Peer#peer{last_seen = Time}, Peers), Peer#peer.uri};
                      {value, _Hash, Peer} ->
                          Peer1 = start_ping_timer(
                                    fun set_max_retry/1,
                                    Peer),
                          {enter_peer(Peer1#peer{last_seen = Time}, Peers),
                           Peer1#peer.uri}
                  end,
              Errored = update_errored(ok, ActualUri, State#state.errored),
              {noreply, State#state{peers = NewPeers, errored = Errored}};
          _Other ->
              lager:debug("Ignoring last_seen (~p): ~p", [Uri, _Other]),
              {noreply, State}
  