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:     KeySize = 0,
  
      <<16#81:8, ?MEMCACHE_INCREMENT:8, KeySize:16, ExtrasSizeOut:8, 0, Status:16,
        BodySizeOut:32, 0:32, 0:64, BodyOut/binary>>;
  
  canned_responses(binary, _Key, Op, already_exists) ->
      ExtrasOut = <<>>,
      ExtrasSizeOut = size(ExtrasOut),
      Status = ?KEY_EXISTS,
  
negative.code: 
  parse_text([<<"get">> | Keys]) -> {[], {get, Keys}};
  parse_text([<<"gets">> | Keys]) -> {[], {gets, Keys}};
  parse_text([<<"set">>, Key, _Flag, _ExpTime, _NBytes, Bytes]) -> {[], {set, Key, Bytes, undefined, false}};
  parse_text([<<"cas">>, Key, _Flag, _ExpTime, _NBytes, CAS, Bytes]) -> {[], {cas, Key, Bytes, binary_to_integer(CAS), undefined, false}};
  parse_text([<<"add">>, Key, _Flag, _ExpTime, _NBytes, Bytes]) -> {[], {add, Key, Bytes, undefined, false}};
  parse_text([<<"delete">>, Key]) -> {[], {delete, Key}};
  parse_text([<<"delete">>, Key, <<"noreply">>, <<>> | Rest]) ->
      parse_multi_delete_text([Key], Rest);
  