anchor.diff:          interface INode with
   
               member this.find(shift, hash, key) =
  -                let bit = BitCount.bitpos(hash, shift)
  +                let bit = bitpos(hash, shift)
                   if this.bitmap &&& bit = 0 then null else
  -                let idx' = BitCount.index(this.bitmap,bit) * 2
  +                let idx' = index(this.bitmap,bit) * 2
                   let keyOrNull = this.array.[idx']
                   let valOrNode = this.array.[idx'+1]
  -                if keyOrNull = null then (valOrNode :?> INode).find(shift + 5, hash, key) else
  -                if key = keyOrNull then
  -                    valOrNode
  -                else 
  -                    null
  +                if keyOrNull = null then 
  +                    (valOrNode :?> INode).find(shift + 5, hash, key) 
  +                else
  +                    if key = keyOrNull then
  +                        valOrNode
  +                    else 
  +                        null
   
               member this.tryFind(shift, hash, key) =
  -                let bit = BitCount.bitpos(hash, shift)
  +                let bit = bitpos(hash, shift)
                   if this.bitmap &&& bit = 0 then None else
  -                let idx = BitCount.index(this.bitmap,bit)
  +                let idx = index(this.bitmap,bit)
                   let keyOrNull = this.array.[2*idx]
                   let valOrNode = this.array.[2*idx+1]
                   if keyOrNull = null then (valOrNode :?> INode).tryFind(shift + 5, hash, key) else
  
positive.code:                         else
                              addedLeaf.Value <- addedLeaf :> obj
                              this.editAndSet(thread1, idx', null, idx'+1, 
                                              NodeHelpers.createNode(thread1, shift + 5, keyOrNull, valOrNode, hashKey, key, value)) :> INode
                  else
                      let n = BitCount.NumberOfSetBits(this.bitmap) * 2
                      let n' = n * 2
                      if n' < this.array.Length then
                          addedLeaf.Value <- addedLeaf :> obj
  
negative.code:                     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, 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)
  