anchor.diff:          let values = List.map (readValue reader) (List.ofSeq indices)
           values
   
  -module MemoryMappedRead =
  +module MemoryMappedSimpleRead =
  +
       open System.IO.MemoryMappedFiles
   
       let readValue (reader:MemoryMappedViewAccessor) offset cellIndex =
  
positive.code:     let testSmallMarspec() =
          let result = testRandomQuery "testSmallMarspec" [|@"D:\a\data\marspec\MARSPEC_10m\ascii\bathy_10m.asc"|] 10 10000 
          printfn "result: %A" result
          
      let testAllBioOracle() =
          ignore // TODO
  
  
negative.code: 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(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+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 =
  
  