anchor.diff:  	  i         = 0                 :: s_i(),
   	  last                          :: transition(),
   	  enabled   = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
  +          blocked   = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
   	  next      = dict:new()        :: dict(), %% dict(lid:lid(), instr()),
   	  backtrack = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
   	  done      = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
  
positive.code: %% STUB
  dependent(TransitionA, TransitionB) -> true.
  
  run_selected(Transition, #flanagan_state{must_replay = true} = State) ->
      run_selected(Transition, replay_trace(State));
  run_selected({Lid, Instruction}, State) ->
      Next = wait_next(Lid, State),
      UpdatedState = handle_instruction(Instruction, Lid, State),
      {Next, UpdatedState}.
  
  %% STUB
  replay_trace(State) ->
      State.
  
  wait_next(Lid, State) ->
      ok = resume(Lid, State),
      receive
          #sched{msg = Type, lid = Lid, misc = Misc} ->
              case Type of
                  error -> {error, Misc};
                  _Else -> {ok, {Lid, {Type, Misc}}}
              end
      end.
  
  resume(Lid, #flanagan_state{lid_to_pid = LidToPid}) ->
      Pid = dict:fetch(Lid, LidToPid),
      Pid ! #sched{msg = continue},
      ok.
  
  %% STUB
  handle_instruction({spawn, Opts}, Lid, State) ->
      Parent = Lid,
      ChildPid =
          receive
              #sched{msg = spawned, lid = Parent, misc = ChildPid0} ->
                  ChildPid0
          end,
      State.
  
  %% STUB
  
negative.code: interleave_flanagan(Target, _PreBound) ->
      {ok, 0}.
  
  explore(MightNeedReplayState) ->
      NewState = 
          case select_from_backtrack(MightNeedReplayState) of
              {ok, Selected, State} ->
                  case wait_next(Selected) of
                      {ok, Next} ->
                          LocalAddState = add_local_backtracks(Selected, State),
                          AllAddState = add_all_backtracks(Next, LocalAddState),
                          UpdState = update_trace(Selected, Next, AllAddState),
                          add_some_next_to_backtrack(UpdState);
                      {error, ErrorInfo} ->
                          report_error(Selected, ErrorInfo, State)
                  end;
              none ->
                  report_no_actives(MightNeedReplayState)
          end,
      explore(NewState).
  
  select_from_backtrack(#flanagan_state{trace = Trace} = MightNeedReplayState) ->
      %% FIXME: Pick first and don't really subtract.
      [TraceTop|RestTrace] = Trace,
      Backtrack = TraceTop#trace_state.backtrack,
      Done = TraceTop#trace_state.done,
      case ordsets:subtract(Backtrack, Done) of
  	[SelectedLid|_RestLids] ->
              State =
                  case MightNeedReplayState#flanagan_state.must_replay of
                      true -> replay_trace(MightNeedReplayState);
                      false -> MightNeedReplayState
                  end,
  	    Instruction = dict:fetch(SelectedLid, TraceTop#trace_state.next),
              NewDone = ordsets:add_element(SelectedLid, Done),
              NewTraceTop = TraceTop#trace_state{done = NewDone},
              NewState = State#flanagan_state{trace = [NewTraceTop|RestTrace]},
  	    {ok, {SelectedLid, Instruction}, NewDone};
  	[] -> none
      end.
  
  add_local_backtracks(Transition, #flanagan_state{trace = Trace} = State) ->
      [TraceTop|RestTrace] = Trace,
      #trace_state{backtrack = Backtrack, next = Next, clock_map = ClockMap} =
          TraceTop,
      NewBacktrack = add_local_backtracks(Transition, Next, ClockMap, Backtrack),
      NewTrace = [TraceTop#trace_state{backtrack = NewBacktrack}|RestTrace],
      State#flanagan_state{trace = NewTrace}.
  
  add_local_backtracks({NLid, _} = Transition, Next, ClockMap, Backtrack) ->
      Fold =
          fun(Lid, Instruction, AccBacktrack) ->
  