anchor.diff:  
           member this.Dispose () =
               udp.Close ()
  -            reader.Close ()
  -            reader.Dispose ()
  -            ms.Close ()
  -            ms.Dispose ()
               (udp :> IDisposable).Dispose ()
   
               
positive.code:     let udp = new UdpClient ()
      let received = Event<BinaryReader> ()
  
      // reliable
      let ms = new MemoryStream (65536)
      let reader = new BinaryReader (ms)
      let mutable reliableSeqN = 0us
  
      let reliablePositions = Array.zeroCreate<int> 65536
      let reliableExists = Array.zeroCreate<bool> 65536
  
negative.code:             }
  
          member this.Heartbeat () =
              packetStream.SetLength (1024L)
              reliableStream.SetLength (65536L)
  
              let mutable startSeqN = reliableSeqN
              let mutable maxSeqN = reliableSeqN
  
              while udp.Available > 0 do
                  packetStream.Position <- 0L
  
                  let mutable endpoint = mainEndpoint :> EndPoint
                  let bytes = udp.Client.ReceiveFrom (packetBuffer, &endpoint)
  
                  if bytes > 0 then
                      let a = packetReader.ReadByte ()
  
                      match Microsoft.FSharp.Core.LanguagePrimitives.EnumOfValue<byte, ServerMessageType> (a) with
                      | ServerMessageType.ReliableOrder ->
  
                          let seqN = packetReader.ReadUInt16 ()
  
                          if reliableExists.[int seqN] then
                              failwith "we have looped all the way around 65536"
  
                          let count = bytes - 3
  
                          if int reliableStream.Position + bytes >= 65536 then
                              failwith "we are over the stream, handle this later"
  
                          reliablePositions.[int seqN] <- int reliableStream.Position
                          reliableExists.[int seqN] <- true
  
  
                          Buffer.BlockCopy (packetBuffer, 3, reliableStream.GetBuffer (), int reliableStream.Position, count)
                          reliableStream.Position <- reliableStream.Position + int64 count
  
  
                          if seqN > maxSeqN || seqN < startSeqN then
                              maxSeqN <- seqN
  