anchor.diff:      max_items,
       items=0,
       size=0,
  -    work_waiter=nil,
  -    close_on_dequeue=false
  +    work_waiters=[],
  +    close_on_dequeue=false,
  +    multi_workers=false
   }).
   
   new(Options) ->
  
positive.code: init(Options) ->
      Q = #q{
          max_size = couch_util:get_value(max_size, Options),
          max_items = couch_util:get_value(max_items, Options)
      },
      {ok, Q}.
  
  terminate(_Reason, #q{work_waiter=nil}) ->
      ok;
  terminate(_Reason, #q{work_waiter={WWFrom, _}}) ->
      gen_server:reply(WWFrom, closed).
      
  handle_call({queue, Item}, From, #q{work_waiter=nil}=Q0) ->
      Q = Q0#q{size=Q0#q.size + byte_size(term_to_binary(Item)),
                  items=Q0#q.items + 1,
                  queue=queue:in(Item, Q0#q.queue)},
  
negative.code:     false ->
          {reply, ok, Q}
      end;
  handle_call({queue, Item}, _From, #q{work_waiters = [{W, _Max} | Rest]} = Q) ->
      gen_server:reply(W, {ok, [Item]}),
      {reply, ok, Q#q{work_waiters=Rest}};
  
  handle_call({dequeue, Max}, From, Q) ->
      #q{work_waiters = Workers, multi_workers = Multi, items = Count} = Q,
      case {Workers, Multi} of
      {[_ | _], false} ->
          exit("Only one caller allowed to wait for this work at a time");
      {[_ | _], true} ->
          {noreply, Q#q{work_waiters=Workers ++ [{From, Max}]}};
      _ ->
          case Count of
          0 ->
              {noreply, Q#q{work_waiters=Workers ++ [{From, Max}]}};
          C when C > 0 ->
              deliver_queue_items(Max, Q)
          end
      end.
  
  deliver_queue_items(Max, Q) ->
      #q{
          queue = Queue,
          items = Count,
          close_on_dequeue = Close,
          blocked = Blocked
      } = Q,
      case (Max =:= all) orelse (Max >= Count) of
      false ->
          {Items, Queue2, Blocked2} = dequeue_items(Max, Queue, Blocked, []),
          Q2 = Q#q{items = Count - Max, blocked = Blocked2, queue = Queue2},
          {reply, {ok, Items}, Q2};
      true ->
          lists:foreach(fun(F) -> gen_server:reply(F, ok) end, Blocked),
          Q2 = Q#q{items = 0, size = 0, blocked = [], queue = queue:new()},
          case Close of
          false ->
              {reply, {ok, queue:to_list(Queue)}, Q2};
          true ->
              {stop, normal, {ok, queue:to_list(Queue)}, Q2}
          end
      end.
  
  dequeue_items(0, Queue, Blocked, DequeuedAcc) ->
  