anchor.diff:                              if nextN <> (thisPageNumber+1) then utils.SeekPage(fs, pageSize, nextN)
                               nextGeneration.Add(thisPageNumber, snd children.[i-1])
                               overflows.Clear()
  -                            (0, 0, nextN, nextB)
  +                            {sofar=0; first=0; nextPage=nextN; boundaryPage=nextB}
                           else
  -                            (sofar, first, nextPageNumber, boundaryPageNumber)
  +                            {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber}
   
                       let addKeyToParent args = 
  -                        let (sofar, firstChild, nextPageNumber, boundaryPageNumber) = args
  +                        let {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber} = args
                           if isLastChild then 
  -                            (sofar, firstChild, nextPageNumber, boundaryPageNumber)
  +                            {sofar=sofar; first=first; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber}
                           else
  -                            let first = if sofar=0 then i else firstChild
  +                            let f1 = if sofar=0 then i else first
                               let sf1 = 
                                   if sofar = 0 then
                                       overflows.Clear()
  
positive.code:                     let couldBeRoot = (nextGeneration.Count = 0)
  
                      let maybeFlush args = 
                          let (sofar, first, nextPageNumber, 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)
  
negative.code: 
                  // 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
                  (n,b,nextGeneration)
  
              let rec writeOneLayerOfParentPages next boundary (children:System.Collections.Generic.List<int32 * byte[]>) :int32 =
  