anchor.diff:      end;
   
   %% Link message handler.
  -handler(link, Pid, Info, TargetPid, DetailsFlag) ->
  +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 DetailsFlag of
  +    case Det of
   	true -> replay_logger:log({link, Lid, TargetLid});
   	false -> continue
       end,
  -    dispatcher(Info, DetailsFlag);
  +    dispatcher(Info);
   
   %% Receive message handler.
  -handler('receive', Pid, Info, {From, Msg}, DetailsFlag) ->
  +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 DetailsFlag of
  +    case Det of
   	true -> replay_logger:log({'receive', Lid, SenderLid, Msg});
   	false -> continue
       end,
  -    dispatcher(Info, DetailsFlag);
  +    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, {DstPid, Msg}, DetailsFlag) ->
  +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 DetailsFlag of
  +    case Det of
   	true -> replay_logger:log({send, Lid, DstLid, Msg});
   	false -> continue
       end,
       NewInfo = wakeup(DstLid, Info),
  -    dispatcher(NewInfo, DetailsFlag);
  +    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, ChildPid, DetailsFlag) ->
  +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 DetailsFlag of
  +    case Det of
   	true -> replay_logger:log({spawn, ParentLid, ChildLid});
   	false -> continue
       end,
  -    NewInfo = dispatcher(Info, DetailsFlag),
  -    dispatcher(NewInfo, DetailsFlag);
  +    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, DetailsFlag) ->
  +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, DetailsFlag);
  +            dispatcher(Info);
           Lid ->
               ?debug_2("Process ~s yields.~n", [Lid]),
               NewActive = sets:add_element(Lid, Active),
  
positive.code:     Parent ! {interleave_result, {Result, Time}}.
  
  %% Main loop for producing process interleavings.
  interleave_loop(Target, RunCounter, Tickets) ->
      interleave_loop(Target, RunCounter, Tickets, false).
  
  interleave_loop(Target, RunCounter, Tickets, DetailsFlag) ->
      %% Lookup state to replay.
      case state:pop() of
          no_state ->
  	    case Tickets of
  		[] -> {ok, RunCounter - 1};
  		_Any -> {error, RunCounter - 1, lists:reverse(Tickets)}
  	    end;
          ReplayState ->
              ?debug_1("Running interleaving ~p~n", [RunCounter]),
              ?debug_1("----------------------~n"),
              %% Start LID service.
              lid:start(),
  
negative.code: 	    dispatcher(Info);
  	_Any ->
  	    ?debug_1("Process ~s exits (~p).~n", [Lid, Reason]),
  	    case Det of
  		true -> replay_logger:log({exit, Lid, Reason});
  		false -> continue
  	    end,
  