anchor.diff:  
       //
       static member (*inline*) private Join (p0, t0 : PatriciaMap<'T>, p1, t1) =
  -        let m = branchingBit' (p0, p1)
  +        let m = branchingBit (p0, p1)
           let p = mask (p0, m)
           if zeroBit (p0, m) then
               Br (p, m, t0, t1)
  
positive.code: 
          map.FoldBack (folder, state)
  
  
      (* TEMP :   The implementations of the functions below should be moved into IntMap members,
                  and replaced with optimized implementations where possible. *)
  
      //
      let choose (chooser : int -> 'T -> 'U option) (map : IntMap<'T>) : IntMap<'U> =
          // Preconditions
          checkNonNull "map" map
  
          let chooser = FSharpFunc<_,_,_>.Adapt chooser
  
          (IntMap.Empty, map)
          ||> fold (fun chosenMap key value ->
              match chooser.Invoke (key, value) with
              | None ->
                  chosenMap
              | Some newValue ->
                  chosenMap.Add (key, newValue))
  
      //
      let filter (predicate : int -> 'T -> bool) (map : IntMap<'T>) : IntMap<'T> =
          // Preconditions
          checkNonNull "map" map
  
          let predicate = FSharpFunc<_,_,_>.Adapt predicate
  
          (map, map)
          ||> fold (fun filteredMap key value ->
              if predicate.Invoke (key, value) then
                  filteredMap
              else
                  filteredMap.Remove key)
  
      //
      let map (mapping : int -> 'T -> 'U) (map : IntMap<'T>) : IntMap<'U> =
          // Preconditions
          checkNonNull "map" map
  
          let mapping = FSharpFunc<_,_,_>.Adapt mapping
  
          (IntMap.Empty, map)
          ||> fold (fun map key value ->
              map.Add (key, mapping.Invoke (key, value)))
  
      //
      let partition (predicate : int -> 'T -> bool) (map : IntMap<'T>) : IntMap<'T> * IntMap<'T> =
          // Preconditions
          checkNonNull "map" map
  
          let predicate = FSharpFunc<_,_,_>.Adapt predicate
  
          ((IntMap.Empty, IntMap.Empty), map)
          ||> fold (fun (trueMap, falseMap) key value ->
              if predicate.Invoke (key, value) then
                  trueMap.Add (key, value),
                  falseMap
              else
                  trueMap,
                  falseMap.Add (key, value))
  
      //
      let mapPartition (partitioner : int -> 'T -> Choice<'U, 'V>) (map : IntMap<'T>) : IntMap<'U> * IntMap<'V> =
          // Preconditions
          checkNonNull "map" map
  
          let partitioner = FSharpFunc<_,_,_>.Adapt partitioner
  
          ((IntMap.Empty, IntMap.Empty), map)
          ||> fold (fun (map1, map2) key value ->
              match partitioner.Invoke (key, value) with
              | Choice1Of2 value ->
                  map1.Add (key, value),
                  map2
              | Choice2Of2 value ->
                  map1,
                  map2.Add (key, value))
  
  
  
      // TODO
      // exists
      // findKey
      // forall
      // pick
      // toSeq
      // tryFindKey
      // tryPick
      // union
  
  
  (* TODO : Can we just implement TagMap as a measure-annotated IntMap? *)
  
negative.code:     let inline lowestBit (x : int) : uint32 =
          uint32 (x &&& -x)
  
      // http://aggregate.org/MAGIC/#Most%20Significant%201%20Bit
      let inline private branchingBitFast (x : uint32) =
          let x = x ||| (x >>> 1)
          let x = x ||| (x >>> 2)
          let x = x ||| (x >>> 4)
          let x = x ||| (x >>> 8)
          let x = x ||| (x >>> 16)
          x &&& ~~~(x >>> 1)
  
      /// Finds the first bit at which p0 and p1 disagree.
      /// Returns a power-of-two value containing this (and only this) bit.
      let inline branchingBit (p0, p1) : uint32 =
          branchingBitFast (p0 ^^^ p1)
  
  
  open BitOps
  