anchor.diff:  open System.Collections
   open System.Linq
   
  +module Dict = 
  +
  +    let tryGetDefault (d:IDictionary<'k,'v>) (key:'k) (defaultValue:'v) =
  +        if d.ContainsKey(key) then
  +            d.[key]
  +        else
  +            defaultValue
  +
   module BitMap =
  +
       type bitmap = System.Collections.BitArray
       let init (bools:bool []) = new System.Collections.BitArray(bools)
   
       let isSet index (b:bitmap) =
  -        b.Get(index)
  -
  -    let countUpto (uptoIndex:int) (b:bitmap) = 
  -        let mutable count = 0
  -        for i=0 to uptoIndex-1 do
  +        b.Get(int index)
  +
  +    let countUpto (uptoIndex:int64) (b:bitmap) = 
  +        let mutable count = 0L
  +        for i=0 to (int uptoIndex)-1 do
               if b.Get(i) then
  -                count <- count+1
  +                count <- count+1L
           count
  +
  +    let countSkippedUpto (uptoIndex:int64) (b:bitmap) =
  +        let count = countUpto uptoIndex b
  +        uptoIndex - count
  +
  +    let sparseIndex (map:bitmap[]) (cellIndex:int64) =
  +        let ncols = int64 map.[0].Length
  +        let rowIndex = cellIndex / ncols
  +        let colIndex = (cellIndex - (rowIndex*ncols))
  +        if isSet colIndex map.[int rowIndex] then
  +            let skippedCount = map |> Seq.take (int rowIndex) |> Seq.map ((countSkippedUpto ncols)>>int64) |> Seq.sum
  +            let skippedCount = skippedCount + int64 (countSkippedUpto colIndex map.[int rowIndex])
  +            Some(cellIndex - skippedCount)
  +        else
  +            None
   
   module PSeqOrdered =
   
  
positive.code:         let values = List.map (readValue reader) (List.ofSeq indices)
          values
  
  module MemoryMappedRead =
      open System.IO.MemoryMappedFiles
  
      let readValue (reader:MemoryMappedViewAccessor) offset cellIndex =
  
negative.code:             sw.Restart()
              let indices = [1..innerlen] |> List.map (fun i -> (int64 (r.Next(0, 2160*1080)) ))
              let indices = indices.OrderBy(fun x -> x)
              result <- Array.map (query indices) sbgPaths
  
              sw.Stop()
              arr.[i] <- sw.ElapsedMilliseconds
  