anchor.diff:                      let idx = this.findIndex(key)
                       if idx <> -1 then
                           if this.array.[idx + 1] = value then this :> INode else
  -                        HashCollisionNode(ref null, hashKey, this.count, NodeHelpers.cloneAndSet(this.array, idx + 1, value)) :> INode
  +                        HashCollisionNode(ref null, hashKey, this.count, cloneAndSet(this.array, idx + 1, value)) :> INode
                       else
                           let newArray = Array.create (2 * (this.count + 1)) null
                           System.Array.Copy(this.array, 0, newArray, 0, 2 * this.count)
  
positive.code:                         
  
              member this.without(shift, hashKey, key) =
                  let bit = BitCount.bitpos(hashKey, shift)
                  if (this.bitmap &&& bit) = 0 then this :> INode else
                  let idx = BitCount.index(this.bitmap,bit)
                  let keyOrNull = this.array.[2*idx]
                  let valOrNode = this.array.[2*idx+1]
                  if keyOrNull = null then
                      let n = (valOrNode :?> INode).without(shift + 5, hashKey, key)
                      if n = (valOrNode :?> INode) then this :> INode else
                      if n <> Unchecked.defaultof<INode> then BitmapIndexedNode(ref null, this.bitmap, NodeHelpers.cloneAndSet(this.array, 2*idx+1, n)) :> INode else
                      if this.bitmap = bit then Unchecked.defaultof<INode> else
                      BitmapIndexedNode(ref null, this.bitmap ^^^ bit, NodeHelpers.removePair(this.array, idx)) :> INode
                  else
                      if key = keyOrNull then
                          // TODO: collapse
                          BitmapIndexedNode(ref null, this.bitmap ^^^ bit, NodeHelpers.removePair(this.array, idx)) :> INode
                      else
                          this :> INode
  
              member this.without(thread1, shift, hashKey, key, removedLeaf) =
                  let bit = BitCount.bitpos(hashKey, shift)
                  if (this.bitmap &&& bit) = 0 then this :> INode else
                  let idx = BitCount.index(this.bitmap,bit)
  
                  let keyOrNull = this.array.[2*idx]
                  let valOrNode = this.array.[2*idx+1]
  
negative.code:                         else
                              addedLeaf.Value <- addedLeaf :> obj
                              this.editAndSet(thread1, idx', null, idx'+1, 
                                              NodeCreation.createNode(thread1, shift + 5, keyOrNull, valOrNode, hashKey, key, value)) :> INode
                  else
                      let n = NumberOfSetBits(this.bitmap) * 2
                      let n' = n * 2
                      if n' < this.array.Length then
                          addedLeaf.Value <- addedLeaf :> obj
  