anchor.diff:  %% active  : A set containing all processes ready to be scheduled.
   %% blocked : A set containing all processes that cannot be scheduled next
   %%          (e.g. waiting for a message on a `receive`).
  -%% error   : A term describing the error that occured.
  -%% state   : The current state of the program.
  +%% current : The LID of the currently running or last run process.
   %% details : A boolean being false when running a normal run and
   %%           true when running a replay and need to send detailed
   %%           info to the replay_logger.
  --record(context, {active  :: set(),
  -                  blocked :: set(),
  +%% error   : A term describing the error that occured.
  +%% state   : The current state of the program.
  +-record(context, {active         :: set(),
  +                  blocked        :: set(),
  +		  current        :: lid:lid(),
  +		  details        :: boolean(),
                     error = normal :: 'normal' | 
   				    error:assertion() |
   				    error:exception(),
  -                  state   :: state:state(),
  -                  details :: boolean()}).
  +                  state          :: state:state()}).
   
   %% Internal message format
   %%
  
positive.code: 
  %% Delegates messages sent by instrumented client code to the appropriate
  %% handlers.
  dispatcher(Context) ->
      receive
  	#sched{msg = Type, pid = Pid, misc = Misc} ->
  	    handler(Type, Pid, Context, Misc);
  	{'EXIT', Pid, Reason} ->
  	    handler(exit, Pid, Context, Reason);
  	Other ->
  	    log:internal("Dispatcher received: ~p~n", [Other])
      end.
  
  %% Main scheduler component.
  
negative.code: 		{NextTemp, RestTemp} = state:trim_head(ReplayState),
  		{NextTemp, RestTemp, {current, []}}
  	end,
      ContextToRun = Context#context{current = Next},
      #context{active = Active, blocked = Blocked, error = Error,
  	     state = State} = RunContext = run(ContextToRun),
      %% Update active and blocked sets, moving Lid from active to blocked,
      %% in the case that if it was run next, it would block.
      Fun = fun(L, Acc) ->
  