anchor.diff:                          // these don't have a header, and they don't have a
                           // boundary ptr at the end.
   
  -                        let sofarAfterRegularPages = writeOverflowRegularPages pb fs ba numRegularPages len sofarAfterFirstPage
  +                        let sofarAfterRegularPages = writeRegularPages numRegularPages sofarAfterFirstPage
   
                           if needed > availableBeforeBoundary then
                               // assert sofar < len
  
positive.code:             pb.PutVarint(int64 vlen)
              pb.PutStream(ba, int vlen)
  
      let private buildOverflowFirstPage (pb:PageBuilder) (ba:Stream) len sofar =
          pb.Reset()
          pb.PutByte(OVERFLOW_NODE)
          pb.PutByte(0uy) // starts 0, may be changed before the page is written
          // check for the partial page at the end
          let num = Math.Min((pb.PageSize - (2 + sizeof<int32>)), (len - sofar))
          pb.PutStream(ba, num)
          // something will be put in lastInt32 before the page is written
          sofar + num
  
      let private writeOverflowRegularPages (pb:PageBuilder) (fs:Stream) (ba:Stream) numPagesToWrite len _sofar =
          let rec fn i sofar =
              if i < numPagesToWrite then
                  pb.Reset()
                  // check for the partial page at the end
                  let num = Math.Min(pb.PageSize, (len - sofar))
                  pb.PutStream(ba, num)
                  pb.Flush(fs)
                  fn (i+1) (sofar + num)
              else
                  sofar
  
          fn 0 _sofar
  
      let private buildOverflowBoundaryPage (pb:PageBuilder) (ba:Stream) len sofar =
          pb.Reset()
          // check for the partial page at the end
          let num = Math.Min((pb.PageSize - sizeof<int32>), (len - sofar))
          pb.PutStream(ba, num)
          // something will be put in lastInt32 before the page is written
          sofar + num
  
      let private countOverflowPagesFor pageSize len = 
          let pages = len / pageSize
          let extra = if (len % pageSize) <> 0 then 1 else 0
          pages + extra
  
      let private writeOverflow (pageManager:IPages) token startingNextPageNumber startingBoundaryPageNumber (pb:PageBuilder) (fs:Stream) (ba:Stream) =
          let len = (int ba.Length)
  
          let rec fn sofarBeforeFirstPage firstPageNumber boundaryPageNumber :int*int =
              // each trip through this loop will write out one
              // block, starting with the overflow first page,
              // followed by zero-or-more "regular" overflow pages,
  
negative.code: 
                          // needed gives us the number of pages, NOT including the first one
                          // which would be necessary to finish this overflow.
                          let needed = countRegularPagesNeeded (len - sofarAfterFirstPage)
  
                          // availableBeforeBoundary is the number of pages until the boundary,
                          // NOT counting the boundary page, and the first page in the block
  