anchor.diff:  
   open Foom.Network
   open Foom.Network.Pipeline
  -
  -let ReceiverSource (packetPool : PacketPool) =
  -
  -    { new ISource with 
  -
  -        member x.Send (data, startIndex, size, output) =
  -            let packet = packetPool.Get ()
  -            packet.Set (data, startIndex, size)
  -            output packet }
  -
  -let ReliableOrderedAckReceiver (packetPool : PacketPool) (ackManager : AckManager) ack =
  -
  -    let mutable nextSeqId = 0us
  -    let queue = Queue<Packet> ()
  -
  -    { new IFilter with
  -
  -        member x.Send packet =
  -            if nextSeqId = packet.SequenceId then
  -                queue.Enqueue packet
  -                nextSeqId <- nextSeqId + 1us
  -            else
  -                ackManager.MarkCopy packet
  -
  -        member x.Process output =
  -            while queue.Count > 0 do
  -                let packet = queue.Dequeue ()
  -                ack packet.SequenceId
  -                output packet
  -
  -            ackManager.ForEachPending (fun seqId copyPacket ->
  -                if int nextSeqId = seqId then
  -                    let packet = packetPool.Get ()
  -                    copyPacket.CopyTo packet
  -                    ackManager.Ack seqId
  -                    ack nextSeqId
  -                    nextSeqId <- nextSeqId + 1us
  -                    output packet
  -            ) }
   
   module NewPipeline =
   
  
positive.code:                     callback packet
              )
          )
  
  let ReliableAckReceiver (packetPool : PacketPool) ack =
  
      let queue = Queue<Packet> ()
  
      { new IFilter with
  
          member x.Send packet =
              queue.Enqueue packet
  
          member x.Process output =
              while queue.Count > 0 do
                  let packet = queue.Dequeue ()
                  ack packet.SequenceId
                  output packet
      }
  
  let ReliableSequencedAckReceiver (packetPool : PacketPool) ack =
  
      let mutable recentFrom = 0us
      let mutable recentTo = 0us
      let queue = Queue<Packet> ()
  
      { new IFilter with
  
          member x.Send packet =
  
              // A new message has been received.
              if sequenceMoreRecent packet.SequenceId recentTo then
  
                  while queue.Count > 0 do
                      packetPool.Recycle (queue.Dequeue ())
  
                  recentFrom <- packet.SequenceId
                  recentTo <- packet.SequenceId + uint16 packet.Fragments
                  queue.Enqueue packet
  
              // The packet could be a fragment of the entire message.
              elif sequenceMoreRecent packet.SequenceId recentFrom then
                  if packet.FragmentId > 0us || packet.Fragments > 0uy then
                      queue.Enqueue packet
                  else
                      failwith "shouldn't happen yet"
                      packetPool.Recycle packet
  
              else
                  packetPool.Recycle packet
              
          member x.Process output =
              while queue.Count > 0 do
                  let packet = queue.Dequeue ()
                  ack packet.SequenceId
                  output packet
      }
  
  [<Struct>]
  type Data = { bytes : byte []; startIndex : int; size : int }
  
negative.code:     NewPipeline.createPipeline receiveFilter
      |> NewPipeline.build
  
  
  