anchor.diff:  % erl> S = <some term>.
   % erl> {S, <<>>} = msgpack:unpack( msgpack:pack(S) ).
   -type reason() ::  enomem | badarg | no_code_matches.
  --type msgpack_term() :: [msgpack_term()] | {[{msgpack_term(),msgpack_term()}]} | integer() | float().
  +-type msgpack_term() :: [msgpack_term()]
  +		      | {[{msgpack_term(),msgpack_term()}]}
  +		      | integer() | float() | binary().
   
   % ===== external APIs ===== %
   -spec pack(Term::msgpack_term()) -> binary().
  -pack(O) when is_integer(O) andalso O < 0 ->
  -    pack_int_(O);
  -pack(O) when is_integer(O) ->
  -    pack_uint_(O);
  -pack(O) when is_float(O) ->
  -    pack_double(O);
  +pack(I) when is_integer(I) andalso I < 0 ->
  +    pack_int_(I);
  +pack(I) when is_integer(I) ->
  +    pack_uint_(I);
  +pack(F) when is_float(F) ->
  +    pack_double(F);
   pack(nil) ->
  -    pack_nil();
  -pack(Bool) when is_atom(Bool) ->
  -    pack_bool(Bool);
  +    << 16#C0:8 >>;
  +pack(true) ->
  +    << 16#C3:8 >>;
  +pack(false) ->
  +    << 16#C2:8 >>;
   pack(Bin) when is_binary(Bin) ->
       pack_raw(Bin);
   pack(List)  when is_list(List) ->
  
positive.code: % FIXME! this should be tail-recursive and without lists:reverse/1
  unpack_array_(<<>>, 0, RetList)   -> {lists:reverse(RetList), <<>>};
  unpack_array_(Remain, 0, RetList) when is_binary(Remain)-> {lists:reverse(RetList), Remain};
  unpack_array_(<<>>, RestLen, _RetList) when RestLen > 0 ->  {more, RestLen};
  unpack_array_(Bin, RestLen, RetList) when is_binary(Bin)->
      case unpack(Bin) of
  	{more, Len} -> {more, Len+RestLen-1};
  	{Term, Rest}-> unpack_array_(Rest, RestLen-1, [Term|RetList])
      end.
  
  
negative.code: % FIXME: write test for unpack_map/1
  -spec unpack_map_(binary(), non_neg_integer(), [{term(), msgpack_term()}])->
      {more, non_neg_integer()} | { any(), binary()}.
  unpack_map_(Bin,  0,  Acc) -> {{lists:reverse(Acc)}, Bin};
  unpack_map_(Bin, Len, Acc) ->
      case unpack(Bin) of
  	{ more, MoreLen } -> { more, MoreLen+Len-1 };
  	{ Key, Rest } ->
  