anchor.diff:          match map with
           | Empty ->
               Empty
  -        | Lf (j, _) as t ->
  +        | Lf (j, _) ->
               if key = j then Empty
  -            else t
  -        | Br (p, m, t0, t1) as t ->
  +            else map
  +        | Br (p, m, t0, t1) ->
               if matchPrefix (key, p, m) then
                   if zeroBit (key, m) then
                       match PatriciaMap.Delete (key, t0) with
  
positive.code:                     | Empty -> t0
                      | right ->
                          Br (p, m, t0, right)
              else t
  
      /// Compute the difference of two PatriciaMaps.
      static member Difference (s, t) : PatriciaMap<'T> =
          match s, t with
          | (Br (p, m, s0, s1) as s), (Br (q, n, t0, t1) as t) ->
              if m = n then
                  if p <> q then s
                  else
  
negative.code:         match map with
          | Empty ->
              Lf (key, value)
          | Lf (j, _) ->
              if j = key then
                  // A binding already exists with the given key.
                  // This method does not overwrite the existing value, so we can
                  // just return the existing map instead of creating an identical new one.
                  map
              else
                  PatriciaMap.Join (key, Lf (key, value), j, map)
          | Br (p, m, t0, t1) ->
              if matchPrefix (key, p, m) then
                  if zeroBit (key, m) then
                      let left = PatriciaMap.TryAdd (key, value, t0)
  
                      // OPTIMIZATION : If the returned map is identical to the original map after
                      // adding the value to it, we can return this map without modifying it.
                      if left === t0 then map
                      else Br (p, m, left, t1)
                  else
                      let right = PatriciaMap.TryAdd (key, value, t1)
                      
                      // OPTIMIZATION : If the returned map is identical to the original map after
                      // adding the value to it, we can return this map without modifying it.
                      if right === t1 then map
                      else Br (p, m, t0, right)
              else
                  PatriciaMap.Join (key, Lf (key, value), p, map)
  
      /// Computes the union of two PatriciaMaps.
      static member Union (s, t) : PatriciaMap<'T> =
          match s, t with
          | Br (p, m, s0, s1), Br (q, n, t0, t1) ->
              if m = n then
                  if p = q then
                      // The trees have the same prefix. Merge the subtrees.
  