anchor.diff:  
   type INode =
       abstract member assoc : int * int * obj  * obj * Box -> INode
  +    abstract member assoc : Thread ref * int * int * obj  * obj * Box -> INode
       abstract member find : int * int * obj -> obj
       abstract member tryFind : int * int * obj -> obj option
       abstract member without : int * int * obj -> INode
  -
  -
  -type NodeHelpers =
  +    abstract member without : Thread ref * int * int * obj * Box -> INode
  +    abstract member SetThread : Thread -> unit
  +
  +
  +type private NodeHelpers =
       static member mask(hash, shift) = (hash >>> shift) &&& 0x01f
       static member bitpos(hash, shift) = 1 <<< NodeHelpers.mask(hash, shift)
   
  
positive.code:         System.Array.Copy(array, 2*(i+1), newArray, 2*i, newArray.Length - 2*i)
          newArray
  
      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)
          let edit = ref null
          (BitmapIndexedNode() :> INode)
              .assoc(shift, key1hash, key1, val1, addedLeaf) // edit
              .assoc(shift, key2hash, key2, val2, addedLeaf) // edit
  
  and HashCollisionNode(thread,hashCollisionKey,count,array:obj[]) =
      let findIndex key =
          let i = ref 0
          while (!i < 2*count) && (key <> array.[!i]) do
              i := !i + 2
          if !i < 2*count then !i else -1
          
      with
      
          interface INode with
              member this.assoc(shift, hashKey, key, value, addedLeaf) : INode = 
                  if hashKey = hashCollisionKey then
                      let idx = findIndex(key)
                      if idx <> -1 then
                          if array.[idx + 1] = value then this :> INode else
                          HashCollisionNode(ref null, hashKey, count, NodeHelpers.cloneAndSet(array, idx + 1, value)) :> INode
  
negative.code:                             if value = valOrNode then this  :> INode else BitmapIndexedNode(ref null, bitmap, NodeHelpers.cloneAndSet(array, 2*idx+1, value)) :> INode
                          else
                              addedLeaf.Value <- addedLeaf
                              BitmapIndexedNode(ref null, bitmap, NodeHelpers.cloneAndSet2(array, 2*idx, null, 2*idx+1, NodeHelpers.createNode(ref null, shift + 5, keyOrNull, valOrNode, hashKey, key, value))) :> INode
                  else
                      let n = NodeHelpers.NumberOfSetBits(bitmap)
                      if n >= 16 then
  