anchor.diff:                                  putOverflow v n b
                       {st with nextPage=newN;boundaryPage=newB;keys=k::st.keys}
                           
  -                // this is the body of the folder function
  +                // this is the body of the foldLeaf function
                   maybeWriteLeaf st |> initLeaf |> addPairToLeaf
   
               // this is the body of writeLeaves
               //let source = seq { csr.First(); while csr.IsValid() do yield (csr.Key(), csr.Value()); csr.Next(); done }
               let initialState = {firstLeaf=0;keys=[];leaves=[];nextPage=leavesFirstPage;boundaryPage=leavesBoundaryPage}
  -            let middleState = Seq.fold folder initialState source
  +            let middleState = Seq.fold foldLeaf initialState source
               let finalState = 
                   if not (List.isEmpty middleState.keys) then
                       let isRootNode = List.isEmpty middleState.leaves
  
positive.code:                 if nextN <> (thisPageNumber+1) then utils.SeekPage(fs, pageSize, nextN)
                  {sofar=0; items=[]; nextPage=nextN; boundaryPage=nextB; overflows=Map.empty; nextGeneration=(thisPageNumber,k)::nextGeneration}
  
              let folder pair st =
                  let (pagenum,k:byte[]) = pair
  
                  let neededEitherWay = 1 + Varint.SpaceNeededFor (int64 k.Length) + Varint.SpaceNeededFor (int64 pagenum)
  
negative.code:                 if nextN <> (thisPageNumber+1) then utils.SeekPage(fs, pageSize, nextN)
                  {keys=[]; firstLeaf=firstLeaf; nextPage=nextN; boundaryPage=nextB; leaves=(thisPageNumber,List.head st.keys)::st.leaves}
  
              let foldLeaf st (pair:kvp) = 
                  let k = pair.Key
                  let v = pair.Value
                  // assert k <> null
  