anchor.diff:  %
   % Check if a node is a member of a bucket list
   %
  -b_is_member(ID, IP, Port, []) ->
  +b_is_member(_, _, _, []) ->
       false;
  -b_is_member(ID, IP, Port, [{Min, Max, Members}|T])
  +b_is_member(ID, IP, Port, [{Min, Max, Members}|_])
   when ?in_range(ID, Min, Max) ->
       lists:member({ID, IP, Port}, Members);
   b_is_member(ID, IP, Port, [_|T]) ->
  
positive.code: handle_call({is_interesting, InputID, IP, Port}, _From, State) -> 
      ID = ensure_int_id(InputID),
      #state{
          buckets=Buckets,
          node_timeout=NTimeout,
          node_access=NAccess} = State,
      IsInteresting = case b_is_member(ID, IP, Port, Buckets) of
          false -> false;
          true ->
              BMembers = b_members(ID, Buckets),   
              DMembers = disconnected(BMembers, NTimeout, NAccess),
              DMembers =/= []
      end,
      {reply, IsInteresting, State};
  
  handle_call({insert_node, InputID, IP, Port}, _From, State) ->
      ID = ensure_int_id(InputID),
      #state{
          node_id=Self,
          buckets=PrevBuckets,
          node_timers=PrevNTimers,
          node_access=PrevNAccess,
          buck_timers=PrevBTimers,
          node_timeout=NTimeout,
          buck_timeout=BTimeout} = State,
  
      IsPrevMember = b_is_member(ID, IP, Port, PrevBuckets),
      Disconnected = case IsPrevMember of
          true  -> [];
          false ->
              PrevBMembers = b_members(ID, PrevBuckets),
              disconnected(PrevBMembers, NTimeout, PrevNAccess)
      end,
  
      {NewBuckets, Deleted} = case {IsPrevMember, Disconnected} of
          {true, _} ->
              % If the node is already a member of the node set,
              % don't change a thing
  
negative.code: 
      % If the new node replaced a new, remove all timer and access time
      % information from the state
      TmpNTimers = case Replace of
          none ->
              PrevNTimers;
          [{_, _, _}=DNode|_] ->
              del_timer(DNode, PrevNTimers)
      end,
  
  
  
      IsNewMember = b_is_member(ID, IP, Port, NewBuckets),
      NewNTimers  = case {IsPrevMember, IsNewMember} of
          {false, false} ->
              TmpNTimers;
          {true, true} ->
              TmpNTimers;
          {false, true}  ->
              NTimer = node_timer_from(Now, NTimeout, Node),
              add_timer(Node, Now, NTimer, TmpNTimers)
      end,
  
      NewBTimers = case {IsPrevMember, IsNewMember} of
          {false, false} ->
              PrevBTimers;
          {true, true} ->
              PrevBTimers;
  
          {false, true} ->
              AllPrevRanges = b_ranges(PrevBuckets),
              AllNewRanges  = b_ranges(NewBuckets),
  
              DelRanges  = subtract(AllPrevRanges, AllNewRanges),
              NewRanges  = subtract(AllNewRanges, AllPrevRanges),
  
              DelBTimers = lists:foldl(fun(Range, Acc) ->
                  del_timer(Range, Acc)
              end, PrevBTimers, DelRanges),
              
              lists:foldl(fun(Range, Acc) ->
                  BMembers = b_members(Range, NewBuckets),
                  LRecent = least_recent(BMembers, NewNTimers),
                  BTimer = bucket_timer_from(
                               Now, BTimeout, LRecent, NTimeout, Range),
                  add_timer(Range, Now, BTimer, Acc)
              end, DelBTimers, NewRanges)
      end, 
      NewState = State#state{
          buckets=NewBuckets,
          node_timers=NewNTimers,
          buck_timers=NewBTimers},
      {reply, ok, NewState};
              
  
  
  
  handle_call({closest_to, InputNodeID, NumNodes}, _, State) ->
      NodeID = ensure_int_id(InputNodeID),
      #state{buckets=Buckets} = State,
      Nodes = b_node_list(Buckets),
  