anchor.diff:        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}
  +      {update_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)}),
  +handle_command({txn, Txn}, _Sender, State) ->
  +  NewState = process_all_queues(push_txn(State, Txn)),
     {reply, ok, NewState}.
   
   handle_coverage(_Req, _KeySpaces, _Sender, State) -> {stop, not_implemented, State}.
  
positive.code: 
  %%%% VNode methods ----------------------------------------------------------+
  
  -spec process_queue(#state{}) -> #state{}.
  process_queue(State=#state{queue=Queue}) ->
    case queue:peek(Queue) of
      empty -> State;
      {value, Txn} ->
        {NewState, Success} = try_store(State, Txn),
        case Success of
          false -> NewState;
          true -> process_queue(NewState#state{queue = queue:drop(Queue)})
        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_the_clock(State, DCID, Timestamp), true};
  
  %% Store the normal transaction
  try_store(State, Txn=#interdc_txn{dcid = DCID, partition = Partition, timestamp = Timestamp, operations = Ops}) ->
  
negative.code: %% VNode state
  -record(state, {
    partition :: partition_id(),
    queues :: dict(), %% DCID -> queue()
    vectorclock :: vectorclock()
  }).
  
  