anchor.diff:                  let work =
                       async {
                           try
  -                            let items =
  -                                values.Items 
  -                                // items are added to the front as they
  -                                // come in reverse them here so they match the order 
  -                                // of arrival
  -                                |> List.rev 
  -                                |> List.map (fun (_,a,_) -> a)
  -                            do! workCallback(nextKey, items) 
  +                            do! workCallback(nextKey,values.Items |> List.rev |> List.map snd) 
                           with | e ->
                               System.Console.WriteLine ("Error" + e.Message)
                           
  -                        for (i, _, groupCompleteTracker) in values.Items do
  +                        for (i, _) in values.Items do
                               lastCompleteTracker.Complete i
  -                            match groupCompleteTracker with
  -                            | Some t -> t.Complete i
  -                            | None -> ()
   
                           agent.Post <| GroupComplete nextKey
                       }
  
positive.code:                 try
                      let items = itemsF ()
                      let indexedItems = Seq.zip items (Seq.initInfinite (fun x -> itemIndex + int64 x)) |> Seq.cache
                      let indexSet = indexedItems |> Seq.map snd |> Set.ofSeq
  
                      let nextIndex = itemIndex + (indexSet |> Set.count |> int64)
  
                      let setCompleteTracker = 
                          match onComplete with
                          | Some a ->
                              Some (new OperationSetComplete<int64>(indexSet, a))
                          | None -> None
  
                      for ((item, group), index) in indexedItems do
                          state.AddItemToGroup (index, item, setCompleteTracker) group
                          do! lastCompleteTracker.Start index
  
                      return! (nextMessage nextIndex) 
                  with | e -> 
  
negative.code: 
  open FSharpx
  
  type GroupEntry<'TItem> = {
      Items : List<Int64 * 'TItem>
      Processing : List<Int64 * 'TItem>
  }
    
  type MutableOrderedGroupingBoundedQueueMessages<'TGroup, 'TItem> = 
  