anchor.diff:  parent_clock(_Clock, Reg) ->
       Reg.
   
  -%% @doc The single total value of a `gcounter()'.
  +%% @doc The values of a `gcounter()'.
   -spec value(mvreg()) -> term().
   value(MVReg) ->
       [Val || {Val, _TS} <- MVReg].
   
  -%% @doc query for this `mvreg()'.
  +%% @doc query for this `mvreg()' of its timestamp.
   %% `timestamp' is the only query option.
  --spec value(mv_q(), mvreg()) -> non_neg_integer().
  +-spec value(mv_q(), mvreg()) -> term().
   value(timestamp, MVReg) ->
       [TS || {_Val, TS} <- MVReg].
   
   %% @doc Assign a `Value' to the `mvreg()'
  -%% associating the update with time `TS'
  +%% associating the update with time `TS'. This kind of update is supposed to be
  +%% linealizable so the assigner does not need to provide the
  +%% timestamp it has observed. The update is only applied if the timestamp
  +%% dominate the current one.
   -spec update(mvreg_op(), term(), mvreg()) ->
                       {ok, mvreg()}.
   update({assign, Value, TS}, Actor, MVReg) ->
  
positive.code:             {ok, MVReg}
      end;
  
  %% For when users don't provide timestamps
  %% don't think it is a good idea to mix server and client timestamps
  update({assign, Value}, Actor, MVReg) ->
      VV = incVV(MVReg, Actor),
      NewMVReg = [{Value, VV}],
      {ok, NewMVReg};
  
  update({propagate, Value, TS}, _, MVReg ) ->
      LocalTS = value(timestamp, MVReg),
      LocalDominate = riak_dt_vclock:dominate(LocalTS, TS),
      RemoteDominate = riak_dt_vclock:dominate(TS, LocalTS),
      case {LocalDominate, RemoteDominate} of 
          {true, false} ->
              {ok, MVReg};
          {false, true} ->
              NewMVReg = {Value, TS},
              {ok, NewMVReg};
          {false, false} ->
              NewMVReg = lists:append(MVReg, [{Value, TS}]),
              {ok, NewMVReg}
      end.
  
  update(Op, Actor, Reg, _Ctx) ->
      update(Op, Actor, Reg).
  
  incVV(MVReg, Actor) ->
      TSL = [TS || {_Val, TS}<- MVReg],
      [H|T] = TSL,
  
negative.code:     NewVC = riak_dt_vclock:increment(Actor, MaxVC),
      NewVC.
  
  %% @doc If the timestamp is larger than all corresponding entries.
  dominate_ts(_TS, _Actor, []) ->
      true;
  dominate_ts(TS, Actor, [H|T]) ->
  