anchor.diff:  %% Discard the exited process (don't add to any set).
   %% If the exited process is irrelevant (i.e. has no LID assigned),
   %% call the dispatcher.
  -handler(exit, Pid, Info, Reason, DetailsFlag) ->
  +handler(exit, Pid, #info{details = Det} = Info, Reason) ->
       Lid = lid:from_pid(Pid),
       case Lid of
   	not_found ->
  
positive.code: %% messages received from the running process to the appropriate handler
  %% functions.
  driver(#info{active = Active, blocked = Blocked,
  	     error = Error, state = State} = Info,
         StateList, DetailsFlag) when is_boolean(DetailsFlag) ->
      %% Assertion violation check.
      case Error of
  	assert -> {error, assert, State};
  
negative.code:     end;
  
  %% Link message handler.
  handler(link, Pid, #info{details = Det} = Info, TargetPid) ->
      Lid = lid:from_pid(Pid),
      TargetLid = lid:from_pid(TargetPid),
      ?debug_1("Process ~s links to process ~s.~n", [Lid, TargetLid]),
      case Det of
  	true -> replay_logger:log({link, Lid, TargetLid});
  	false -> continue
      end,
      dispatcher(Info);
  
  %% Receive message handler.
  handler('receive', Pid, #info{details = Det} = Info, {From, Msg}) ->
      Lid = lid:from_pid(Pid),
      SenderLid = lid:from_pid(From),
      ?debug_1("Process ~s receives message `~p` from process ~s.~n",
  	    [Lid, Msg, SenderLid]),
      case Det of
  	true -> replay_logger:log({'receive', Lid, SenderLid, Msg});
  	false -> continue
      end,
      dispatcher(Info);
  
  %% Send message handler.
  %% When a message is sent to a process, the receiving process has to be awaken
  %% if it is blocked on a receive.
  %% XXX: No check for reason of blocking for now. If the process is blocked on
  %%      something else, it will be awaken!
  handler(send, Pid, #info{details = Det} = Info, {DstPid, Msg}) ->
      Lid = lid:from_pid(Pid),
      DstLid = lid:from_pid(DstPid),
      ?debug_1("Process ~s sends message `~p` to process ~s.~n",
  	    [Lid, Msg, DstLid]),
      case Det of
  	true -> replay_logger:log({send, Lid, DstLid, Msg});
  	false -> continue
      end,
      NewInfo = wakeup(DstLid, Info),
      dispatcher(NewInfo);
  
  %% Spawn message handler.
  %% First, link the newly spawned process to the scheduler process.
  %% The new process yields as soon as it gets spawned and the parent process
  %% yields as soon as it spawns. Therefore wait for two `yield` messages using
  %% two calls to the dispatcher.
  handler(spawn, ParentPid, #info{details = Det} = Info, ChildPid) ->
      link(ChildPid),
      ParentLid = lid:from_pid(ParentPid),
      ChildLid = lid:new(ChildPid, ParentLid),
      ?debug_1("Process ~s spawns process ~s.~n", [ParentLid, ChildLid]),
      case Det of
  	true -> replay_logger:log({spawn, ParentLid, ChildLid});
  	false -> continue
      end,
      NewInfo = dispatcher(Info),
      dispatcher(NewInfo);
  
  %% Yield message handler.
  %% Receiving a `yield` message means that the process is preempted, but
  %% remains in the active set.
  handler(yield, Pid, #info{active = Active} = Info, _Misc) ->
      case lid:from_pid(Pid) of
          %% This case clause avoids a possible race between `yield` message
          %% of child and `spawn` message of parent.
          not_found ->
              ?RP_SCHED ! #sched{msg = yield, pid = Pid},
              dispatcher(Info);
          Lid ->
              ?debug_2("Process ~s yields.~n", [Lid]),
              NewActive = sets:add_element(Lid, Active),
  