anchor.diff:                          if flushThisPage then
                               // assert sofar > 0
                               let thisPageNumber = nextPageNumber
  -                            let subList = children |> Seq.skip first |> Seq.take (i - first) |> Seq.toList
  -                            buildParentPage subList (fst children.[i]) overflows
  +                            // TODO needing to reverse the items list is rather unfortunate
  +                            buildParentPage (List.rev items) (fst children.[i]) overflows
                               let isRootNode = isLastChild && couldBeRoot
                               let (nextN,nextB) =
                                   if isRootNode then
  
positive.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;overflows=Map.empty}
                  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 =
  
negative.code:                     let couldBeRoot = (nextGeneration.Count = 0)
  
                      let maybeFlush args = 
                          let {sofar=sofar; items=items; nextPage=nextPageNumber; boundaryPage=boundaryPageNumber; overflows=overflows} = 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)
  