anchor.diff:              false
           | Lf (j, listSet) ->
               j = valueHash
  -            && ListSet.Contains (value, listSet)
  +            && List.contains value listSet
           | Br (_, m, t0, t1) ->
               PatriciaHashSet.Contains (
                   valueHash, value, (if zeroBit (valueHash, m) then t0 else t1))
  
positive.code:         | Empty ->
              None
          | Lf (_, listSet) ->
              ListSet.TryFind (predicate, listSet)
          | Br (_,_,_,_) ->
              /// The stack of trie nodes pending traversal.
              let stack = Stack (defaultTraversalStackSize)
  
negative.code: //        | Empty, _ ->
  //            Empty
  
      /// Computes the containment ordering for two sets (i.e., determines if one set includes the other).
      // Return values:
      //  -1 : All values in 't1' are in 't2', and at least one value of 't2' is not in 't1'.
      //   0 : The sets contain _exactly_ the same values.
      //   1 : The sets are disjoint, i.e., 't1' contains at least one value which is not in 't2'.
      static member private SubsetCompare (t1 : PatriciaHashSet<'T>, t2 : PatriciaHashSet<'T>) : int =
          notImpl "PatriciaHashSet.SubsetCompare"
  (*
          match t1, t2 with
          | Br (p1, m1, l1, r1), Br (p2, m2, l2, r2) ->
              if shorter (m1, m2) then 1
              elif shorter (m2, m1) then
                  if not <| matchPrefix (p1, p2, m2) then 1
                  elif zeroBit (p1, m2) then
                      match PatriciaHashSet.SubsetCompare (t1, l2) with 1 -> 1 | _ -> -1
                  else
                      match PatriciaHashSet.SubsetCompare (t1, r2) with 1 -> 1 | _ -> -1
              elif p1 = p2 then
                  let left = PatriciaHashSet.SubsetCompare (l1, l2)
                  let right = PatriciaHashSet.SubsetCompare (r1, r2)
                  match left, right with
                  | 1, _
                  | _, 1 -> 1
                  | 0, 0 -> 0
                  | _ -> -1
              else
                  // The maps are disjoint.
                  1
  
          | Br (_,_,_,_), (Empty | Lf (_,_)) -> 1
          | Lf x, Lf y ->
              if x = y then 0
              else 1
  
          | Lf x, Br (p, m, l, r) ->
              if not <| matchPrefix (x, p, m) then 1
              elif zeroBit (x, m) then
                  match PatriciaSet.SubsetCompare (t1, l) with 1 -> 1 | _ -> -1
              else
                  match PatriciaSet.SubsetCompare (t1, r) with 1 -> 1 | _ -> -1
  
          | Lf _, Empty ->
              // The maps are disjoint.
              1
  
          | Empty, Empty -> 0
          | Empty, _ -> -1
  *)
      /// Is 'set1' a proper subset of 'set2'?
      /// IsProperSubset (set1, set2) returns true if all keys in set1 are in set2,
      /// and at least one element in set2 is not in set1.
      static member IsProperSubset (set1 : PatriciaHashSet<'T>, set2 : PatriciaHashSet<'T>) : bool =
          match PatriciaHashSet.SubsetCompare (set1, set2) with
          | -1 -> true
          | _ -> false
  
      /// Is 'set1' a subset of 'set2'?
      /// IsSubset (set1, set2) returns true if all keys in set1 are in set2.
      static member IsSubset (set1 : PatriciaHashSet<'T>, set2 : PatriciaHashSet<'T>) : bool =
          match PatriciaHashSet.SubsetCompare (set1, set2) with
          | -1 | 0 -> true
          | _ -> false
  
      //
      static member OfSeq (source : seq<'T>) : PatriciaHashSet<'T> =
  