anchor.diff:                i=Indexes}=Q) ->
       [
        {history, {call, Backend, put, [bucket(Q), key(Q), index_specs(), val(), State]}},
  +     {history, {call, ?MODULE, async_put, [bucket(Q), key(Q), val(), Backend, State]}},
        {history, {call, Backend, get, [bucket(Q), key(Q), State]}},
        {history, {call, ?MODULE, delete, [bucket(Q), key(Q), Backend, State, Indexes]}},
        {history, {call, Backend, fold_buckets, [fold_buckets_fun(), get_fold_buffer(), g_opts(), State]}},
  
positive.code: next_state_data(_From, _To, S, _R, {call, _M, put, [Bucket, Key, IndexSpecs, Val, _]}) ->
      S#qcst{d = orddict:store({Bucket, Key}, Val, S#qcst.d),
             i = update_indexes(Bucket, Key, IndexSpecs, S#qcst.i)};
  next_state_data(_From, _To, S, _R, {call, _M, delete, [Bucket, Key|_]}) ->
      D1 = orddict:erase({Bucket, Key}, S#qcst.d),
      D2 = try
  
negative.code:     {ok, S} = Backend:start(Partition, Config),
      S.
  
  async_put(Bucket, Key, Val, Backend, BeState) ->
      case erlang:function_exported(Backend, async_put, 5) of
          true ->
              %% Imperfect, not overlapping puts
              %% TODO: Refine model to check for received messages
              Context = {some_context, make_ref()},
              {ok, BeState2} = Backend:async_put(Context, Bucket, Key, Val, BeState),
              receive
                  {Context, Reply} ->
                      {Reply, BeState2};
                  Other ->
                      {error, {unexpected_message, Other}}
              after
                  5000 ->
                      {error, async_put_timeout}
              end;
          false  ->
              Backend:put(Bucket, Key, [], Val, BeState)
      end.
  
  drop(Backend, State) ->
      State1 = case Backend:drop(State) of
                   {ok, NewState} ->
  