anchor.diff:      KeySize = 0,
   
       <<16#81:8, Op:8, KeySize:16, ExtrasSizeOut:8, 0, Status:16,
  -      BodySizeOut:32, 0:32, 0:64, BodyOut/binary>>;
  -
  -canned_responses(binary, _Key, ?MEMCACHE_INCREMENT, {incr, I}) ->
  +      BodySizeOut:32, (opaque(Index)):32,
  +      0:64, BodyOut/binary>>;
  +
  +canned_responses(binary, Index, _Key, ?MEMCACHE_INCREMENT, {incr, I}) ->
       ExtrasOut = <<>>,
       ExtrasSizeOut = size(ExtrasOut),
       Status = ?NO_ERROR,
  
positive.code:     KeySize = 0,
  
      <<16#81:8, Op:8, KeySize:16, ExtrasSizeOut:8, 0, Status:16,
        BodySizeOut:32, 0:32, 0:64, BodyOut/binary>>;
  
  canned_responses(binary, _Key, _Op, noop)       -> [].
  
  text_response_get_keys(_Port, [], Acc, _WithCas) ->
      [Acc,  "END\r\n"];
  
negative.code:                 binary ->
                      binary_response_get_keys(Port, Keys, [], true)
              end;
          {Kind, {set, Key, Bytes, Index, Quiet}} ->
              put_key(Port, Key, Bytes),
              unless_quiet(Quiet, canned_responses(Kind, Index, Key, ?MEMCACHE_SET, stored));
          {Kind, {cas, Key, Bytes, CAS, Index, Quiet}} ->
              case get_key(Port, Key) of
                  undefined ->
                      ct:log("cas of non-existent key ~p", [Key]),
                      canned_responses(Kind, Index, Key, ?MEMCACHE_SET, not_found);
                  {_, CAS} ->
                      ct:log("cas of existing key ~p with correct token ~p", [Key, CAS]),
                      put_key(Port, Key, Bytes, CAS + 1),
                      unless_quiet(Quiet, canned_responses(Kind, Index, Key, ?MEMCACHE_SET, stored));
                  {_, ExpectedCAS} ->
                      ct:log("cas of existing key ~p with incorrect token ~p (wanted ~p)",
                             [Key, CAS, ExpectedCAS]),
                      canned_responses(Kind, Index, Key, ?MEMCACHE_SET, already_exists)
              end;
          {Kind, {delete, Key}} ->
              ct:log("deleting ~p", [Key]),
              case get_key(Port, Key) of
                  undefined ->
                      ct:log("was not present"),
                      canned_responses(Kind, undefined, Key, ?MEMCACHE_DELETE, not_found);
                  {_Value, _} ->
                      ct:log("key was present"),
                      put_key(Port, Key, undefined, undefined),
                      canned_responses(Kind, undefined, Key, ?MEMCACHE_DELETE, deleted)
              end;
          {Kind, {add, Key, Bytes, Index, Quiet}} ->
              case get_key(Port, Key) of
                  undefined ->
                      put_key(Port, Key, Bytes, undefined),
                      unless_quiet(Quiet, canned_responses(Kind, Index, Key, ?MEMCACHE_ADD, stored));
                  {_Value, _} ->
                      canned_responses(Kind, Index, Key, ?MEMCACHE_ADD, not_stored)
              end;
          {Kind, {incr, Key, ExpTime, Initial, Bytes}} ->
              case get_key(Port, Key) of
  