anchor.diff:      let inline mask(hash, shift) = (hash >>> shift) &&& 0x01f
       let inline bitpos(hash, shift) = 1 <<< mask(hash, shift)
       let inline index(bitmap,bit) = NumberOfSetBits(bitmap &&& (bit - 1))
  -             
  -type private NodeHelpers =
  -
  -    static member cloneAndSet(array:INode[], i, a) =
  +
  +module private NodeHelpers =
  +    let inline cloneAndSet(array:obj[], i, a) =
           let clone = Array.copy array
           clone.[i] <- a
           clone
   
  -    static member cloneAndSet(array:obj[], i, a) =
  +    let inline cloneAndSetNodes(array:INode[], i, a) =
           let clone = Array.copy array
           clone.[i] <- a
           clone
   
  -    static member cloneAndSet2(array:obj[], i, a, j, b) =
  +    let inline cloneAndSet2(array, i, a, j, b) =
           let clone = Array.copy array
           clone.[i] <- a
           clone.[j] <- b
           clone
   
  -    static member removePair(array:obj[], i) =
  +    let inline removePair(array:obj[], i) =
           let newArray = Array.create (array.Length - 2) null
           System.Array.Copy(array, 0, newArray, 0, 2*i)
           System.Array.Copy(array, 2*(i+1), newArray, 2*i, newArray.Length - 2*i)
           newArray
   
  -    static member createNode(thread, shift, key1, val1, key2hash, key2, val2) =
  -        let key1hash = hash(key1)
  -
  -        if key1hash = key2hash then HashCollisionNode(ref null, key1hash, 2, [|key1; val1; key2; val2|]) :> INode else 
  -        
  -        let addedLeaf = Box(null)
  -        (BitmapIndexedNode() :> INode)
  -            .assoc(thread, shift, key1hash, key1, val1, addedLeaf)
  -            .assoc(thread, shift, key2hash, key2, val2, addedLeaf)
  -
  -    static member createNode(shift, key1, val1, key2hash, key2, val2) =
  -        let key1hash = hash(key1)
  -
  -        if key1hash = key2hash then HashCollisionNode(ref null, key1hash, 2, [|key1; val1; key2; val2|]) :> INode else 
  -        
  -        let addedLeaf = Box(null)
  -        (BitmapIndexedNode() :> INode)
  -            .assoc(ref null, shift, key1hash, key1, val1, addedLeaf)
  -            .assoc(ref null, shift, key2hash, key2, val2, addedLeaf)
  -
  -    static member createNodeSeq(array: obj[], i) =
  +
  +    let inline createNodeSeq(array: obj[]) = 
           seq {
  -            let j = ref i
  +            let j = ref 0
               while !j < array.Length do                
                   let isNode = array.[!j+1] :? INode
                   
  
positive.code:                             this.ensureEditable(thread1, this.count + 1, newArray) :> INode
                  else
                      // nest it in a bitmap node
                      (BitmapIndexedNode(thread1, BitCount.bitpos(hashCollisionKey, shift), [| null; this; null; null |]) :> INode)
                          .assoc(thread1, shift, hashKey, key, value, addedLeaf);
  
              member this.find(shift, hash, key) =
  
negative.code:                     else
                          if n >= 16 then
                              let nodes = Array.create 32 Unchecked.defaultof<INode>
                              let jdx = mask(hashKey, shift)
                              nodes.[jdx] <- (BitmapIndexedNode() :> INode).assoc(thread1, shift + 5, hashKey, key, value, addedLeaf)
                              let mutable j = 0
                              for i in 0..31 do
  