anchor.diff:  %% VNode state
   -record(state, {
     partition :: partition_id(),
  -  queue :: queue(),
  +  queues :: dict(), %% DCID -> queue()
     vectorclock :: vectorclock()
   }).
   
  
positive.code:       ClockSiOps = updates_to_clocksi_payloads(Txn),
  
        ok = lists:foreach(fun(Op) -> materializer_vnode:update(Op#clocksi_payload.key, Op) end, ClockSiOps),
        {update_the_clock(State, DCID, Timestamp), true}
    end.
  
  handle_command({txn, Txn}, _Sender, State=#state{queue=Queue}) ->
    NewState = process_queue(State#state{queue = queue:in(Txn, Queue)}),
    {reply, ok, NewState}.
  
  handle_coverage(_Req, _KeySpaces, _Sender, State) -> {stop, not_implemented, State}.
  
negative.code: 
  %%%% VNode methods ----------------------------------------------------------+
  
  %% Check the content of each queue, try to apply as many elements as possible.
  %% If any element was successfully pushed from any queue, repeat the process.
  -spec process_all_queues(#state{}) -> #state{}.
  process_all_queues(State = #state{queues = Queues}) ->
    DCIDs = dict:fetch_keys(Queues),
    {NewState, NumUpdated} = lists:foldl(fun process_queue/2, {State, 0}, DCIDs),
    case NumUpdated of
      0 -> NewState;
      _ -> process_all_queues(NewState)
    end.
  
  %% Tries to process as many elements in the queue as possible.
  %% Returns the new state and the number of processed elements
  process_queue(DCID, {State, Acc}) ->
    Queue = dict:fetch(DCID, State#state.queues),
    case queue:peek(Queue) of
      empty -> {State, Acc};
      {value, Txn} ->
        {NewState, Success} = try_store(State, Txn),
        case Success of
          false -> {NewState, Acc};
          true -> process_queue(DCID, {pop_txn(NewState, DCID), Acc + 1}) %% remove the just-applied txn and retry
      end
    end.
  
  %% Store the heartbeat message.
  %% This is not a true transaction, so its dependencies are always satisfied.
  -spec try_store(#state{}, #interdc_txn{}) -> {#state{}, boolean}.
  try_store(State, #interdc_txn{dcid = DCID, timestamp = Timestamp, operations = []}) ->
    {update_clock(State, DCID, Timestamp), true};
  
  %% Store the normal transaction
  try_store(State, Txn=#interdc_txn{dcid = DCID, partition = Partition, timestamp = Timestamp, operations = Ops}) ->
  