anchor.diff:  %% since there can be diverged value in this register.
   -spec value(mvreg()) -> [term()].
   value(MVReg) ->
  -    [Val || {Val, _TS} <- MVReg].
  +    [Val || {Val, _VC} <- MVReg].
   
   %% @doc query for this `mvreg()' of its timestamp.
   %% `timestamp' is the only query option.
  --spec value(mv_q(), mvreg()) -> [term()].
  +-spec value(mv_q(), mvreg()) -> [riak_dt_vclock:vclock()].
   value(timestamp, MVReg) ->
  -    [TS || {_Val, TS} <- MVReg].
  +    [VC || {_Val, VC} <- MVReg].
   
   %% @doc Assign `Value' to this register. The vector clock of this
   %% register will be incremented by one for the corresponding `Actor'.
  
positive.code: %%
  %% This kind of update is supposed to be linealizable so the operation
  %% issuer does not need to provide the vector clock it has observed.
  -spec update(mvreg_op(), term(), mvreg()) ->
                      {ok, mvreg()}.
  update({assign, Value}, Actor, MVReg) ->
      VV = inc_vv(MVReg, Actor),
      NewMVReg = [{Value, VV}],
  
negative.code: %% @doc Find a least-uppder bound for all non-compatible vector clocks
  %% in MVReg (if there is any) and then increment timestamp for `Actor'
  %% by one.
  -spec inc_vv(mvreg(), actor()) -> riak_dt_vclock:vclock().
  inc_vv(MVReg, Actor) ->
      VCL = [VC || {_Val, VC} <- MVReg],
      [H|T] = VCL,
      MaxVC = lists:foldl(fun(VC, Acc) -> riak_dt_vclock:merge([VC, Acc]) end, H, T),
      NewVC = riak_dt_vclock:increment(Actor, MaxVC),
      NewVC.
  
  %% @doc If `TS'(timestamp) is larger than all entries of `Actor' for the
  %% MVReg.
  -spec larger_than(ts(), actor(), mvreg()) -> boolean().
  larger_than(_TS, _Actor, []) ->
      true;
  larger_than(TS, Actor, [H|T]) ->
      {_Value, VC} = H,
      OldTS = riak_dt_vclock:get_counter(Actor, VC),
      case  TS > OldTS of
  	true ->
  	    larger_than(TS, Actor, T);
  	false ->
  	    false
      end.
  
  
  %% @doc Merge the first `mvreg()' to the second `mvreg()'. Note that the
  %% first `mvreg()' is local and can have multiple vector clocks, while
  