anchor.diff:  
       % N fastest interesteds should be kept
       {Downloaders, Rest} =
  -	find_fastest_downloaders(?DEFAULT_NUM_DOWNLOADERS,
  -			   Interested),
  +	find_fastest_peers(?DEFAULT_NUM_DOWNLOADERS,
  +			   Interested, S),
       unchoke_peers(Downloaders),
   
       % All peers not interested should be unchoked
  
positive.code: %% API
  -export([start_link/4, add_peers/2, uploaded_data/2, downloaded_data/2,
  	peer_interested/1, peer_not_interested/1, peer_choked/1,
  	peer_unchoked/1, got_piece_from_peer/2, new_incoming_peer/2]).
  
  %% gen_server callbacks
  -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
  
negative.code: 		  end,
  		  S).
  
  sort_fastest_downloaders(Peers) ->
      lists:sort(
        fun ({_K1, PI1}, {_K2, PI2}) ->
  	      PI1#peer_info.downloaded > PI2#peer_info.downloaded
        end,
        dict:to_list(Peers)).
  
  sort_fastest_uploaders(Peers) ->
      lists:sort(
        fun ({_K1, PI1}, {_K2, PI2}) ->
  	      PI1#peer_info.uploaded > PI2#peer_info.uploaded
        end,
        dict:to_list(Peers)).
  
  find_fastest(N, Interested, F) ->
      List = F(Interested),
      PidList = lists:map(fun({K, _V}) -> K end, List),
      SplitPoint = lists:min([length(PidList), N]),
      {Downloaders, Rest} = lists:split(SplitPoint, PidList),
      {Downloaders, Rest}.
  
  find_fastest_peers(N, Interested, S) when S#state.mode == leeching ->
      find_fastest(N, Interested, fun sort_fastest_downloaders/1);
  find_fastest_peers(N, Interested, S) when S#state.mode == seeding ->
      find_fastest(N, Interested, fun sort_fastest_uploaders/1).
  
  unchoke_peers(Pids) ->
      lists:foreach(fun(P) -> torrent_peer:unchoke(P) end, Pids),
  