anchor.diff:  -type decrement_op() :: decrement | {decrement, pos_integer()}.
   -type pncounter_q()  :: positive | negative.
   
  --type v1_pncounter() :: {riak_dt_gcounter:gcounter(),riak_dt_gcounter:gcounter()}.
  +-type v1_pncounter() :: {riak_dt_gcounter:gcounter(), riak_dt_gcounter:gcounter()}.
   -type version()      :: integer().
   -type any_pncounter() :: pncounter() | v1_pncounter().
   
  
positive.code: -spec current_version(any_pncounter()) -> version().
  current_version(PNCnt) when is_list(PNCnt) ->
      ?V2_VERS;
  current_version({_P,_N}) ->
      ?V1_VERS.
  
  -spec change_versions(version(), version(), any_pncounter()) -> any_pncounter().
  change_versions(Version, Version, PNCnt)  ->
      PNCnt;
  change_versions(?V1_VERS, ?V2_VERS, {P,N}) ->
      PNCnt0 = new(),
      PNCnt1 = lists:foldl(fun({Actor,Inc},PNCnt) ->
                                   {ok, PNCnt2} = update({increment,Inc}, Actor, PNCnt),
                                   PNCnt2
                           end, PNCnt0, P),
      PNCnt2 = lists:foldl(fun({Actor,Dec},PNCnt) ->
                                   {ok, PNCnt2} = update({decrement,Dec}, Actor, PNCnt),
                                   PNCnt2
                           end, PNCnt1, N),
      PNCnt2;
  change_versions(?V2_VERS, ?V1_VERS, PNCnt) when is_list(PNCnt) ->
      OldPN = {riak_dt_gcounter:new(), riak_dt_gcounter:new()},
      {P, N} = lists:foldl(fun({Actor,Inc,Dec},{P1,N1}) ->
                                   {ok, Inc2} = riak_dt_gcounter:update({increment,Inc},Actor,P1),
                                   {ok, Dec2} = riak_dt_gcounter:update({increment,Dec},Actor,N1),
                                   {Inc2, Dec2}
                           end, OldPN, PNCnt),
      {P, N}.
  
negative.code:     {ok, PNCnt1} = update(increment, 1, PNCnt0),
      {ok, PNCnt2} = update(increment, 2, PNCnt1),
      {ok, PNCnt3} = update(increment, 1, PNCnt2),
      ?assertEqual([{1, 2, 0}, {2, 1, 0}], PNCnt3).
  
  update_increment_by_test() ->
      PNCnt0 = new(),
      {ok, PNCnt1} = update({increment, 7}, 1, PNCnt0),
      ?assertEqual([{1, 7, 0}], PNCnt1).
  
  update_decrement_test() ->
      PNCnt0 = new(),
  