anchor.diff:                              let newRange = pageManager.GetRange(token)
                               nextPageNumber <- fst newRange
                               boundaryPageNumber <- snd newRange
  -                            // assert pb.Position <= (pb.PageSize - 4)
  +                            // assert pb.Position <= (pageSize - 4)
                               pb.SetLastInt32(nextPageNumber)
                           else
                               nextPageNumber <- nextPageNumber + 1
                       pb.Flush(fs)
  -                    if nextPageNumber <> (thisPageNumber+1) then utils.SeekPage(fs, pb.PageSize, nextPageNumber)
  +                    if nextPageNumber <> (thisPageNumber+1) then utils.SeekPage(fs, pageSize, nextPageNumber)
                       nextGeneration.Add(thisPageNumber, snd children.[i-1])
                       sofar <- 0
                       first <- 0
  
positive.code:                     first <- i
                      overflows.Clear()
                      sofar <- PAGE_OVERHEAD
                  if calcAvailable (pb.PageSize) sofar (nextGeneration.Count = 0) >= neededForInline then
                      sofar <- sofar + k.Length
                  else
                      let keyOverflowFirstPage = nextPageNumber
  
negative.code:         // 5 for the extra ptr we will add at the end, a varint, 5 is worst case
          // 4 for lastInt32
          let PAGE_OVERHEAD = 2 + 2 + 5 + 4
  
          let calcAvailable currentSize couldBeRoot =
              let basicSize = pageSize - currentSize
              let allowanceForRootNode = if couldBeRoot then sizeof<int32> else 0 // first/last Leaf, lastInt32 already
              basicSize - allowanceForRootNode
  
          let buildParentPage (overflows:System.Collections.Generic.Dictionary<int,int32>) (children:System.Collections.Generic.List<int32 * byte[]>) stop start =
              // assert stop > start
              let countKeys = stop - start
              pb.Reset ()
              pb.PutByte (PARENT_NODE)
              pb.PutByte (0uy)
              pb.PutInt16 (countKeys)
              // store all the ptrs, n+1 of them
              // note loop bounds
              for q in start .. stop do
                  pb.PutVarint(int64 (fst (children.[q])))
              // store all the keys, n of them
              // note loop bounds
              for q in start .. (stop-1) do
                  let k = snd children.[q]
                  if ((overflows <> null) && overflows.ContainsKey (q)) then
                      pb.PutByte(FLAG_OVERFLOW)
                      pb.PutVarint(int64 k.Length)
                      pb.PutInt32(overflows.[q])
                  else
                      putArrayWithLength pb k
  
          // assert children.Count > 1
          for i in 0 .. children.Count-1 do
  