anchor.diff:  
                   reply.Reply work
   
  -                let newValues = { values with Items = List.empty; Processing = values.Items }
  -                groupItems.Remove(nextKey) |> ignore
  -                groupItems.Add(nextKey, newValues)
                   return! nextMessage itemIndex }
               and nextMessage itemIndex = async {
  -                let currentQueueSize = workQueue.Count
  +                let currentQueueSize = state.GetWorkQueueCount()
                   if(currentQueueSize = 0) then
                       return! empty itemIndex
                   elif currentQueueSize >= maxItems then
  
positive.code: 
                  return! (nextMessage nextIndex) }
              and groupComplete group itemIndex = async {
                  let values = groupItems.Item group
                  if (not (values.Items |> List.isEmpty)) then
                      workQueue.Enqueue(group)
                  else
                      groupItems.Remove group |> ignore
  
                  return! nextMessage itemIndex }
              and consume (workCallback, reply) itemIndex = async {
                  let nextKey = workQueue.Dequeue()
                  let values = groupItems.Item nextKey
                  let work =
                      async {
                          try
  
negative.code:   | GroupComplete of 'TGroup
    | NotifyWhenAllComplete of AsyncReplyChannel<unit>
  
  type internal MutableOrderedGroupingBoundedQueueState<'TGroup, 'TItem when 'TGroup : comparison> () =
      // normal .NET dictionary for performance
      // very mutable
      let groupItems = new System.Collections.Generic.SortedDictionary<'TGroup, GroupEntry<'TItem>>()
  
      let workQueue = new System.Collections.Generic.Queue<'TGroup>()
  
      let mutable itemIndex = 0L
      let mutable lastIndex = -1L
  
      member x.GetGroupItemsCount () =
          let g = groupItems
          g.Count
  
      member x.GetWorkQueueCount () =
          workQueue.Count
  
      member x.AddItemToGroup item group =
          let (exists, value) = groupItems.TryGetValue(group)
          let value = 
              if exists then
  