anchor.diff:                                   {_,{Key,{Op,Actor}}} = Update,
                                    Dc_id = dc_utilities:get_my_dc_id(),
                                    New_op = #clocksi_payload{
  -                                            key = Key, type = riak_dt_pncounter,
  -                                            op_param = {Op, Actor},
  -                                            snapshot_time = Vec_snapshot_time,
  -                                            commit_time = {Dc_id,Commit_time},
  -                                            txid = TxId},
  +                                             key = Key, type = riak_dt_pncounter,
  +                                             op_param = {Op, Actor},
  +                                             snapshot_time = Vec_snapshot_time,
  +                                             commit_time = {Dc_id,Commit_time},
  +                                             txid = TxId},
                                    lists:append(Operations, [New_op])
                            end,
                            Pending, Updates);
  
positive.code: -include("floppy.hrl").
  -include_lib("riak_core/include/riak_core_vnode.hrl").
  
  -record(dstate, {partition, last_commit_time, pending_operations}).
  
  -export([start_vnode/1,
           trigger/2]).
  
negative.code:                              pending_operations = Pending}) ->
      Pending_operations = add_to_pending_operations(Pending, Write_set),
      lager:info("Pending Operations ~p",[Pending_operations]),
      %% reply to the caller
      From ! {ok, trigger_received},
      %% Calculate stable commit time to order operations
      Node = {Partition, node()}, %% Send ack to caller and continue processing
      Stable_time = get_stable_time(Node, Last_commit_time),
      %% Send a message to itself to process operations
      riak_core_vnode_master:command([{Partition,node()}],
                                     {process},
                                     clocksi_downstream_generator_vnode_master),
      {reply, {ok, trigger_received}, State#dstate{
                                        pending_operations = Pending_operations,
                                        stable_time = Stable_time}};
  
  handle_command({process}, _Sender,
                 State=#dstate{partition = Partition,
                               last_commit_time = Last_commit_time,
                               pending_operations = Pending_operations,
                               stable_time = Stable_time}) ->
      lager:info("Take updates before time : ~p",[Stable_time]),
      Sorted_ops = filter_operations(Pending_operations,
                                     Stable_time, Last_commit_time),
  