anchor.diff:  init([Partition]) ->
       {ok, #state{partition=Partition,
                   max_ts=0,
  -                seq=0,
  -                dreads_uid=dict:new(),
  -                dreads_counters=dict:new(),
  -                label_uid=dict:new(),
                   last_label=none,
  -                buffer=dict:new()}}.
  +                seq=0}}.
   
   %% @doc The table holding the prepared transactions is shared with concurrent
   %%      readers, so they can safely check if a key they are reading is being updated.
  
positive.code:          update/4,
           propagate/4,
           heartbeat/2,
           update_completed/5,
           check_ready/1]).
  
  -record(state, {partition,
                  seq :: non_neg_integer(),
                  dreads_uid :: dict(),
                  dreads_counters :: dict(),
                  label_uid :: dict(),
                  last_label,
                  max_ts,
                  myid,
                  buffer :: queue()}).
  
  %% API
  start_vnode(I) ->
      riak_core_vnode_master:get_vnode_pid(I, ?MODULE).
  
  read(Node, Key) ->
      riak_core_vnode_master:sync_command(Node,
  
negative.code:     ?BACKEND_CONNECTOR_FSM:start_link(read, {Key, From}),
      {noreply, S0};
  
  handle_command({update, Key, Value, Clock}, _From, S0=#state{max_ts=MaxTS0, seq=Seq0, partition=Partition}) ->
      PhysicalClock = saturn_utilities:now_microsec(),
      TimeStamp = max(Clock, max(PhysicalClock, MaxTS0)),
      Seq1=Seq0+1,
      ?BACKEND_CONNECTOR_FSM:start_link(update, {Key, Value, TimeStamp, Seq1}),
      {reply, {ok, TimeStamp}, S0#state{max_ts=TimeStamp, seq=Seq1, last_label={Key, TimeStamp, {Partition, node()}}}};
  
  handle_command({update_completed, Key, Value, TimeStamp, Seq}, _From, S0=#state{partition=Partition, myid=MyId}) ->
      Label = {Key, TimeStamp, {Partition, node()}},
  