anchor.diff:  % evaluate_block([X|XS], PrevIndex, EndIndex, FSMState, MonitorState) ->
   
     ScopeEndIndex = block_size(Block) + 1,
  -  EvalRes = evaluate_block(Block, 0, ScopeEndIndex, FSMState1, MonitorState2),
  +  io:format("ScopeEndIndex top level: ~p~n", [ScopeEndIndex]),
  +  EvalRes = evaluate_block(Block, 0, ScopeEndIndex, orddict:new(), FSMState1, MonitorState2),
     case EvalRes of
       {FSMState2, MonitorState3} ->
         FSMState3 = add_state(end_state(), FSMState2),
  
positive.code: % end index of the block, and FSM state.
  % Returns next ID, FSM with either a new state and a transition to it, or a transition
  %  to the end state added.
  evaluate_comm_transition(CommAST, PrevID, FSMState) ->
    RunningID = get_running_id(FSMState),
    FSMState1 = add_state(standard_state(), FSMState),
    add_comm_transition(CommAST, PrevID, RunningID, FSMState1).
  
  
  
  % Takes the ID of the previously-created node, end index, FSM state, monitor state.
  % On each step?
  
negative.code: block_size([]) -> 0;
  block_size([X]) ->
    instruction_size(X);
  % FIXME: Hack
  block_size([{par, _}|XS]) -> block_size(XS);
  block_size([_|[{continue, _}|_]]) -> 0;
  block_size([X|XS]) ->
    instruction_size(X) + 1 + block_size(XS).
  
  instruction_size({rec, _, Block}) ->
    block_size(Block);
  instruction_size({choice, _, Choices}) ->
    lists:foldl(fun(ChoiceBlock, Sum) ->
                Sum + (block_size(ChoiceBlock)) end, 0, Choices);
  instruction_size(_) -> 0.
  
  % add_state: Takes FSMState, returns (new state ID, new FSMState)
  add_state(State, FSMState) ->
  