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:     member __.FoldBack (folder : int -> 'T -> 'State -> 'State, state : 'State) : 'State =
          trie.FoldBack (folder, state)
  
  
  //
  and [<Sealed>]
  
negative.code: 
          map.FoldBack (folder, state)
  
      //
      let inline choose (chooser : int -> 'T -> 'U option) (map : IntMap<'T>) : IntMap<'U> =
          // Preconditions
          checkNonNull "map" map
  
          map.Choose chooser
  
      //
      let inline filter (predicate : int -> 'T -> bool) (map : IntMap<'T>) : IntMap<'T> =
          // Preconditions
          checkNonNull "map" map
  
          map.Filter predicate
  
      //
      let inline map (mapping : int -> 'T -> 'U) (map : IntMap<'T>) : IntMap<'U> =
          // Preconditions
          checkNonNull "map" map
  
          map.Map mapping
  
      //
      let inline partition (predicate : int -> 'T -> bool) (map : IntMap<'T>) : IntMap<'T> * IntMap<'T> =
          // Preconditions
          checkNonNull "map" map
  
          map.Partition predicate
  
      //
      let inline mapPartition (partitioner : int -> 'T -> Choice<'U, 'V>) (map : IntMap<'T>) : IntMap<'U> * IntMap<'V> =
          // Preconditions
          checkNonNull "map" map
  
          map.MapPartition partitioner
  
      //
      let inline tryFindKey (predicate : int -> 'T -> bool) (map : IntMap<'T>) : int option =
          // Preconditions
          checkNonNull "map" map
  
          map.TryFindKey predicate
  
      //
      let inline exists (predicate : int -> 'T -> bool) (map : IntMap<'T>) : bool =
          // Preconditions
          checkNonNull "map" map
  
          map.Exists predicate
  
      //
      let inline forall (predicate : int -> 'T -> bool) (map : IntMap<'T>) : bool =
          // Preconditions
          checkNonNull "map" map
  
          map.Forall predicate
  
      //
      let inline tryPick (picker : int -> 'T -> 'U option) (map : IntMap<'T>) : 'U option =
          // Preconditions
          checkNonNull "map" map
  
          map.TryPick picker
  
      //
      let inline pick (picker : int -> 'T -> 'U option) (map : IntMap<'T>) : 'U =
          // Preconditions
          checkNonNull "map" map
  
          map.Pick picker
  
      //
      let inline toSeq (map : IntMap<'T>) =
          // Preconditions
          checkNonNull "map" map
  
          map.ToSeq ()
  
  
  
  (* TODO : Can we just implement TagMap as a measure-annotated IntMap? *)
  