anchor.diff:                          reliableExists.[i] <- false
                           let position = reliablePositions.[i]
   
  -                        ms.Position <- int64 position
  -                        received.Trigger (reader)
  +                        reliableStream.Position <- int64 position
  +                        received.Trigger (reliableReader)
                           reliableSeqN <- uint16 i
                       else
                           missingPackets <- true
  
positive.code:             }
  
          member this.Heartbeat () =
              reader.BaseStream.Position <- 0L
              ms.SetLength (65536L)
  
              let mutable startSeqN = reliableSeqN
              let mutable maxSeqN = reliableSeqN
  
              while udp.Available > 0 do
  
                  let mutable endpoint = mainEndpoint :> EndPoint
                  let buffer = ms.GetBuffer ()
                  let bytes = udp.Client.ReceiveFrom (buffer, int ms.Position, 1024, SocketFlags.None, &endpoint)
  
                  if bytes > 0 then
                      let a = reader.ReadByte ()
  
                      match Microsoft.FSharp.Core.LanguagePrimitives.EnumOfValue<byte, ServerMessageType> (a) with
                      | ServerMessageType.ReliableOrder ->
  
                          let seqN = reader.ReadUInt16 ()
  
                          if reliableExists.[int seqN] then
                              failwith "we have looped all the way around 65536"
  
                          reliableExists.[int seqN] <- true
                          reliablePositions.[int seqN] <- int ms.Position
                          ms.Position <- ms.Position + int64 (bytes - 3)
  
                          if seqN > maxSeqN || seqN < startSeqN then
                              maxSeqN <- seqN
  
negative.code: 
          member this.Dispose () =
              udp.Close ()
              (udp :> IDisposable).Dispose ()
  
              