anchor.diff:      // else alloc new path
       //return  nodeToInsert placed in copy of parent
       let subidx = ((vector.Count - 1) >>> level) &&& 0x01f
  -    let ret = Node(Array.copy parent.Array)
  +    let ret = Array.copy parent
   
       let nodeToInsert =
           if level = 5 then tailnode else
   
  -        let child = parent.Array.[subidx]
  +        let child = parent.[subidx]
           if child <> null then
               pushTail(vector,level-5,child :?> Node,tailnode)
           else
               newPath(level-5,tailnode)
   
  -    ret.Array.[subidx] <- nodeToInsert :> obj
  +    ret.[subidx] <- nodeToInsert :> obj
       ret
   
   let inline arrayFor<'a> i (vector:PersistentVector<'a>) =
  
positive.code:         persistentVector<'a>(vector.Count + 1,vector.Shift,vector.Root,newTail)
      else
          //full tail, push into tree
          let tailNode = Node(vector.Tail)
          let newShift = vector.Shift
  
          //overflow root?
          if (vector.Count >>> 5) > (1 <<< vector.Shift) then
              let newRoot = Node()
              newRoot.Array.[0] <- vector.Root :> obj
              newRoot.Array.[1] <- newPath(vector.Shift,tailNode) :> obj
              persistentVector<'a>(vector.Count + 1,vector.Shift + 5,newRoot,[| x |])
          else
              let newRoot = pushTail(vector,vector.Shift,vector.Root,tailNode)
  
negative.code:             let level = ref vector.Shift
              while !level > 0 do
                  let pos = (i >>> !level) &&& 0x01f
                  node := (!node).[pos] :?> Node
                  level := !level - 5
  
              !node
      else raise Exceptions.OutOfBounds
  
  let nth<'a> i (vector:PersistentVector<'a>) : 'a =
  