anchor.diff:      saturn_leaf_producer:partition_heartbeat(MyId, Partition, Clock, Seq1),
       riak_core_vnode:send_command_after(?HEARTBEAT_FREQ, {heartbeat, MyId}),
       {noreply, S0#state{myid=MyId, seq=Seq1}};
  +
  +handle_command(last_label, _Sender, S0=#state{last_label=LastLabel}) ->
  +    {reply, {ok, LastLabel}, S0};
   
   handle_command(Message, _Sender, State) ->
       ?PRINT({unhandled_command, Message}),
  
positive.code: 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()}}.
  
  %% @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.
  
negative.code:          update/4,
           propagate/4,
           heartbeat/2,
           last_label/1,
           update_completed/5,
           check_ready/1]).
  
  -record(state, {partition,
                  seq :: non_neg_integer(),
                  max_ts,
                  last_label,
                  myid}).
  
  %% API
  start_vnode(I) ->
      riak_core_vnode_master:get_vnode_pid(I, ?MODULE).
  
  %Testing purposes
  last_label(Key) ->
      DocIdx = riak_core_util:chash_key({?BUCKET, Key}),
      PrefList = riak_core_apl:get_primary_apl(DocIdx, 1, ?PROXY_SERVICE),
      [{IndexNode, _Type}] = PrefList,
      riak_core_vnode_master:sync_command(IndexNode,
                                          last_label,
                                          ?PROXY_MASTER).
  
  read(Node, Key) ->
      riak_core_vnode_master:sync_command(Node,
  