anchor.diff:  send_after(Server, Time, Dest, Msg) ->
       case Server of
           native -> erlang:send_after(Time, Dest, Msg);
  -        Server -> gen_server:call(Server, {send_after, Time, Dest, Msg})
  +        Server -> gen_server:call(Server, {message, Time, Dest, Msg})
       end.
   
   
  
positive.code: delete_timer(Timer, Timers) ->
      #timer{reference=Ref} = Timer,
      lists:keydelete(Ref, #timer.reference, Timers).
  
  min_interval(Timers) ->
      %% Assume that timers are sorted by interval.
  
negative.code:         %% Timer has already fired and message has been delivered
          false ->
              {reply, false, State};
          %% Deliver the message before this call returns to let us step
          %% ahead in time and create a case where the timer has fired and
          %% the message is in the inbox when the client cancels a timer.
          #timer{interval=0} ->
              deliver(Timer),
              NewTimers = delete_timer(Timer, Timers),
              NewState = State#state{timers=NewTimers},
              {reply, false, NewState};
          %% Timer has not yet fired, just delete the timer and
          %% return the amount of milliseconds left on the timer.
          _ ->
              #timer{interval=Interval} = Timer,
              NewTimers = delete_timer(Timer, Timers),
              NewState = State#state{timers=NewTimers},
              {reply, Interval, NewState}
      end;
  
  handle_call(step, _, State) ->
      #state{timers=Timers} = State,
      Min = min_interval(Timers),
      NewTimers = subtract(Min, Timers),
      NewState = State#state{timers=NewTimers},
      {reply, Min, NewState};
  
  handle_call(fire, _, State) ->
      #state{timers=Timers} = State,
      FiredTimers = with_interval(0, Timers),
      [deliver(Timer) || Timer <- FiredTimers],
      NewTimers = delete_timers(FiredTimers, Timers),
      NewState = State#state{timers=NewTimers},
      NumFired = length(FiredTimers),
      {reply, NumFired, NewState}.
      
  
  handle_cast(_, _) ->
      error(badarg).
  
  
  handle_info(_, _) ->
      error(badarg).
  
  
  terminate(_, State) ->
      {ok, State}.
  
  
  code_change(_, _, _) ->
      error(badarg).
  
  
      
  