anchor.diff:                      let mutable level = shift
                       while level > 0 do
                           let pos = (i >>> level) &&& 0x01f
  -                        node <- node.[pos] :?> Node
  +                        node <- node.Array.[pos] :?> Node
                           level <- level - 5
   
  -                    node
  +                    node.Array
               else raise Exceptions.OutOfBounds
   
           member this.nth i =
  
positive.code:         if count < 32 then 0 else
          ((count - 1) >>> 5) <<< 5
  
      new() = PersistentVector<'a>(0,5,Array.create 32 null,[||])
  
      with
          static member ofSeq(items:'a seq) =
  
negative.code:                 PersistentVector<'a>(count + 1,shift,root,newTail)
              else
                  //full tail, push into tree
                  let tailNode = Node(root.Thread,tail)
                  let newShift = shift
  
                  //overflow root?
                  if (count >>> 5) > (1 <<< shift) then
                      let newRoot = Node(root.Thread,Array.create 32 null)
                      newRoot.Array.[0] <- root :> obj
                      newRoot.Array.[1] <- this.NewPath(shift,tailNode) :> obj
                      PersistentVector<'a>(count + 1,shift + 5,newRoot,[| x |])
                  else
                      let newRoot = this.PushTail(shift,root,tailNode)
                      PersistentVector<'a>(count + 1,shift,newRoot,[| x |])
  
          member internal this.doAssoc(level,node:Node,i,x) =
              let ret = Node(root.Thread,Array.copy node.Array)
              if level = 0 then 
                  ret.Array.[i &&& 0x01f] <- x :> obj 
              else
                  let subidx = (i >>> level) &&& 0x01f
                  ret.Array.[subidx] <- this.doAssoc(level - 5, node.Array.[subidx] :?> Node, i, x) :> obj
              ret
  
          member this.assocN<'a> i (x:'a) : PersistentVector<'a> =
  