anchor.diff:                  binary ->
                       binary_response_get_keys(Port, Keys, [], true)
               end;
  -        {Kind, {set, Key, Bytes}} ->
  +        {Kind, {set, Key, Bytes, Index, Quiet}} ->
               put_key(Port, Key, Bytes),
  -            canned_responses(Kind, Key, ?MEMCACHE_SET, stored);
  -        {Kind, {cas, Key, Bytes, CAS}} ->
  +            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, Key, ?MEMCACHE_SET, not_found);
  +                    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),
  -                    canned_responses(Kind, Key, ?MEMCACHE_SET, stored);
  +                    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, Key, ?MEMCACHE_SET, already_exists)
  +                    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, Key, ?MEMCACHE_DELETE, not_found);
  +                    canned_responses(Kind, undefined, Key, ?MEMCACHE_DELETE, not_found);
                   {_Value, _} ->
                       ct:log("key was present"),
                       put_key(Port, Key, undefined, undefined),
  -                    canned_responses(Kind, Key, ?MEMCACHE_DELETE, deleted)
  +                    canned_responses(Kind, undefined, Key, ?MEMCACHE_DELETE, deleted)
               end;
  -        {Kind, {add, Key, Bytes}} ->
  +        {Kind, {add, Key, Bytes, Index, Quiet}} ->
               case get_key(Port, Key) of
                   undefined ->
                       put_key(Port, Key, Bytes, undefined),
  -                    canned_responses(Kind, Key, ?MEMCACHE_ADD, stored);
  +                    unless_quiet(Quiet, canned_responses(Kind, Index, Key, ?MEMCACHE_ADD, stored));
                   {_Value, _} ->
  -                    canned_responses(Kind, Key, ?MEMCACHE_ADD, not_stored)
  +                    canned_responses(Kind, Index, Key, ?MEMCACHE_ADD, not_stored)
               end;
           {Kind, {incr, Key, ExpTime, Initial, Bytes}} ->
               case get_key(Port, Key) of
  
positive.code:     {[], {get, parse_get([], Bin)}};
  parse_binary(<<16#80:8, ?MEMCACHE_GETKQ:8, _/binary>> = Bin) ->
      {[], {get, parse_get([], Bin)}};
  parse_binary(<<16#80:8, ?MEMCACHE_SET:8, KeySize:16,
                 ExtrasSize:8, 16#00:8, 16#00:16,
                 _BodySize:32, 16#00:32, CAS:64,
                 _Extras:ExtrasSize/binary,
                 Key:KeySize/binary, Value/binary>>) ->
      case CAS of
          16#00 ->
              {[], {set, Key, Value}};
          _ ->
              {[], {cas, Key, Value, CAS}}
      end;
  parse_binary(<<16#80:8, ?MEMCACHE_ADD:8, KeySize:16,
                 ExtrasSize:8, 16#00:8, 16#00:16,
                 _BodySize:32, 16#00:32, 16#00:64,
                 _Extras:ExtrasSize/binary,
                 Key:KeySize/binary, Value/binary>>) ->
      {[], {add, Key, Value}};
  parse_binary(<<16#80:8, ?MEMCACHE_DELETE:8, KeySize:16,
                 ExtrasSize:8, 16#00:8, 16#00:16,
                 _BodySize:32, 16#00:32, 16#00:64,
  
negative.code: 
  %%%% Response
  
  canned_responses(text, _Index, _Key, _Op, not_found)      -> ["NOT_FOUND", <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, not_stored)     -> ["NOT_STORED", <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, stored)         -> [<<"STORED">>, <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, already_exists) -> [<<"EXISTS">>, <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, deleted)        -> [<<"DELETED">>, <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, {incr, I})      -> [mero_util:to_bin(I), <<"\r\n">>];
  canned_responses(text, _Index, _Key, _Op, noop)           -> [];
  
  
  canned_responses(binary, Index, _Key, Op, not_found) ->
      ExtrasOut = <<>>,
      ExtrasSizeOut = size(ExtrasOut),
      Status = ?NOT_FOUND,
      BodyOut = <<>>,
      BodySizeOut = size(BodyOut),
      KeySize = 0,
      <<16#81:8, Op:8, KeySize:16, ExtrasSizeOut:8, 0, Status:16,
        BodySizeOut:32, (opaque(Index)):32,
        0:64, BodyOut/binary>>;
  
  canned_responses(binary, Index, _Key, Op, not_stored) ->
      ExtrasOut = <<>>,
      ExtrasSizeOut = size(ExtrasOut),
      Status = ?NOT_STORED,
  