anchor.diff:  
   open FSharpx
   
  -type GroupEntryItem<'TItem> = Int64 * 'TItem * Option<OperationSetComplete<Int64>>
   type GroupEntry<'TItem> = {
  -    Items : List<GroupEntryItem<'TItem>>
  -    Processing : List<GroupEntryItem<'TItem>>
  +    Items : List<Int64 * 'TItem>
  +    Processing : List<Int64 * 'TItem>
   }
     
   type MutableOrderedGroupingBoundedQueueMessages<'TGroup, 'TItem> = 
  
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:                 let work =
                      async {
                          try
                              do! workCallback(nextKey,values.Items |> List.rev |> List.map snd) 
                          with | e ->
                              System.Console.WriteLine ("Error" + e.Message)
                          
                          for (i, _) in values.Items do
                              lastCompleteTracker.Complete i
  
                          agent.Post <| GroupComplete nextKey
                      }
  