anchor.diff:                  let PARENT_PAGE_OVERHEAD = 2 + 2 + 5 + 4
   
                   let nextGeneration = new System.Collections.Generic.List<int32 * byte[]>()
  -                let overflows = new System.Collections.Generic.Dictionary<int,int32>()
   
                   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 stop start =
  +                let buildParentPage stop start (overflows:Map<int,int32>) =
                       // assert stop > start
                       let countKeys = stop - start
                       pb.Reset ()
  
positive.code:                             pb.Flush(fs)
                              if nextN <> (thisPageNumber+1) then utils.SeekPage(fs, pageSize, nextN)
                              nextGeneration.Add(thisPageNumber, snd children.[i-1])
                              overflows.Clear()
                              {sofar=0; first=0; nextPage=nextN; boundaryPage=nextB}
                          else
                              {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber}
  
                      let addKeyToParent args = 
                          let {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber} = args
                          if isLastChild then 
                              {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber}
                          else
                              let f1 = if sofar=0 then i else first
                              let sf1 = 
                                  if sofar = 0 then
                                      overflows.Clear()
                                      PARENT_PAGE_OVERHEAD
                                  else
                                      sofar
                              let (sf2,nextN,nextB) = 
                                  if calcAvailable sofar (nextGeneration.Count = 0) >= neededForInline then
                                      (neededForInline, nextPageNumber, boundaryPageNumber)
                                  else
                                      let keyOverflowFirstPage = nextPageNumber
                                      let kRange = writeOverflow nextPageNumber boundaryPageNumber (new MemoryStream(k))
                                      overflows.[i] <- keyOverflowFirstPage
                                      (neededForOverflow, (fst kRange), (snd kRange))
                              {sofar=sf1 + sf2; first=f1; nextPage=nextN; boundaryPage=nextB}
  
  
                      // this is the body of the folder function
                      let (_,args) = st
                      let args' = maybeFlush args |> addKeyToParent
                      (i+1,args') 
  
                  // TODO this would be much happier if children were already an F# list
                  let fsChildren = List.ofSeq children
                  let initialArgs = {sofar=0;first=0;nextPage=startingPageNumber;boundaryPage=startingBoundaryPageNumber}
                  let initialState = (0,initialArgs)
                  let finalState = List.fold folder initialState fsChildren
                  let (_,{sofar=_;first=_;nextPage=n;boundaryPage=b}) = finalState
  
negative.code:             nextPage:int; 
              boundaryPage:int; 
              //children:(int32*byte[]); 
              overflows:Map<int,int32>;
          }
  
      let Create(fs:Stream, pageManager:IPages, csr:ICursor) :int32 = 
  