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:                     // p contains q. Merge s with a subtree of t.
                      if zeroBit (p, n) then
                          let left = PatriciaMap.Union (s, t0)
                          Br (q, n, left, t1)
                      else
                          let right = PatriciaMap.Union (s, t1)
                          Br (q, n, t0, right)
                  else
                      // The prefixes disagree.
                      PatriciaMap.Join (p, s, q, t)
  
          | (Br (p, m, s0, s1) as s), Lf (k, x) ->
              if matchPrefix (k, p, m) then
                  if zeroBit (k, m) then
                      let left = PatriciaMap.TryAdd (k, x, s0)
                      Br (p, m, left, s1)
                  else
                      let right = PatriciaMap.TryAdd (k, x, s1)
                      Br (p, m, s0, right)
              else
                  PatriciaMap.Join (k, Lf (k, x), p, s)
  
          | (Br (_,_,_,_) as s), Empty ->
              s
          | Lf (k, x), t ->
              PatriciaMap.Add (k, x, t)
          | Empty, t -> t
  
      /// Compute the intersection of two PatriciaMaps.
      /// If both maps contain a binding with the same key, the binding from
      /// the first map will be used.
      static member Intersect (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 Empty
                  else
  
negative.code:                     | Empty -> t0
                      | right ->
                          Br (p, m, t0, right)
              else map
  
      /// Compute the difference of two PatriciaMaps.
      static member Difference (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 s
                  else
  