anchor.diff:  
                       if writeThisPage then
                           writeLeaf st false true
  +                    else
  +                        st
   
                   let addPairToLeaf (st:LeafState) =
                       let available = pb.Available - sizeof<int32> // for the lastInt32
  
positive.code:     type private LeafState =
          // TODO considered making this a struct, but it doesn't make much/any perf difference
          {
              mutable keys:(byte[] list) // TODO we apparently only use the count and head of this list
              mutable firstLeaf:int32
              mutable leaves:pgitem list 
              mutable blk:PageBlock
          }
  
      let CreateFromSortedSequenceOfKeyValuePairs(fs:Stream, pageManager:IPages, source:seq<kvp>) = 
  
negative.code:                             else
                                  let tmpBlk = putOverflow (new MemoryStream(k)) blk
                                  putOverflow v tmpBlk
                      {st with blk=newBlk;keys=k::st.keys}
                          
                  // this is the body of the foldLeaf function
                  maybeWriteLeaf st |> addPairToLeaf
  
              // this is the body of writeLeaves
              //let source = seq { csr.First(); while csr.IsValid() do yield (csr.Key(), csr.Value()); csr.Next(); done }
              initLeaf 0
              let initialState = {firstLeaf=0;keys=[];leaves=[];blk=leavesBlk}
              let middleState = Seq.fold foldLeaf initialState source
              let finalState = 
                  if not (List.isEmpty middleState.keys) then
                      let isRootNode = List.isEmpty middleState.leaves
                      writeLeaf middleState isRootNode false
                  else
                      middleState
              let {blk=blk;leaves=leaves;firstLeaf=firstLeaf} = finalState
              (blk,leaves,firstLeaf)
  
          // this is the body of Create
          let startingBlk = pageManager.GetBlock(token)
  