anchor.diff:  
                   // TODO this would be much happier if children were already an F# list
                   let fsChildren = List.ofSeq children
  -                let initialArgs = (0,0,startingPageNumber,startingBoundaryPageNumber)
  +                let initialArgs = {sofar=0;first=0;nextPage=startingPageNumber;boundaryPage=startingBoundaryPageNumber}
                   let initialState = (0,initialArgs)
                   let finalState = List.fold folder initialState fsChildren
  -                let (_,(_,_,n,b)) = finalState
  +                let (_,{sofar=_;first=_;nextPage=n;boundaryPage=b}) = finalState
                   (n,b,nextGeneration)
   
               let rec writeOneLayerOfParentPages next boundary (children:System.Collections.Generic.List<int32 * byte[]>) :int32 =
  
positive.code:                                     let kRange = writeOverflow nextPageNumber boundaryPageNumber (new MemoryStream(k))
                                      overflows.[i] <- keyOverflowFirstPage
                                      (neededForOverflow, (fst kRange), (snd kRange))
                              (sf1 + sf2, first, nextN, nextB)
  
  
                      // this is the body of the folder function
  
negative.code:                     let couldBeRoot = (nextGeneration.Count = 0)
  
                      let maybeFlush args = 
                          let {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber} = args
                          // TODO flush logic used to be guarded by if sofar > 0.  should it still be?
                          let available = calcAvailable sofar couldBeRoot
                          let fitsInline = (available >= neededForInline)
  