anchor.diff:              | Empty -> true
               | _ -> false
   
  +    /// The first element in the set.
  +    /// If the element type has suitable hash and comparison functions for the set
  +    /// to be ordered, then this will be the minimum element of the set.
  +    [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
  +    member __.First
  +        with get () =
  +            PatriciaHashSet.First trie
  +
  +    /// The last element in the set.
  +    /// If the element type has suitable hash and comparison functions for the set
  +    /// to be ordered, then this will be the maximum element of the set.
  +    [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
  +    member __.Last
  +        with get () =
  +            PatriciaHashSet.Last trie
  +
       /// Tests if an element is in the domain of the HashSet.
       member __.Contains (value : 'T) : bool =
           let valueHash = uint32 <| hash value
  
positive.code:         | Br (_, m, t0, t1) ->
              PatriciaHashSet.Contains (
                  valueHash, value, (if zeroBit (valueHash, m) then t0 else t1))
  
      //
      static member Count (set : PatriciaHashSet<'T>) : int =
  
negative.code:             if trie === trie' then this
              elif otherSet.Trie === trie' then otherSet
              else HashSet (trie')
  
      /// Computes the union of a sequence of IntSets.
      static member internal UnionMany (sets : seq<HashSet<'T>>) : HashSet<'T> =
          // Preconditions
          checkNonNull "sets" sets
  
          let combinedTrie =
              (PatriciaHashSet.Empty, sets)
              ||> Seq.fold (fun combinedSetTree set ->
                  PatriciaHashSet.Union (combinedSetTree, set.Trie))
  
          HashSet (combinedTrie)
  
      /// Computes the intersection of a sequence of IntSets.
      static member internal IntersectMany (sets : seq<HashSet<'T>>) : HashSet<'T> =
          // Preconditions
          checkNonNull "sets" sets
  
          // If the sequence is empty, return an empty set;
          // this also avoids Seq.reduce raising an exception.
          if Seq.isEmpty sets then
              HashSet.Empty
          else
              Seq.reduce (fun s1 s2 -> s1.Intersect s2) sets
  
      /// Determines if set1 is a subset of set2.
      // IsSubsetOf (set1, set2) returns true if all keys in set1 are in set2.
      static member IsSubset (set1 : HashSet<'T>, set2 : HashSet<'T>) : bool =
          PatriciaHashSet.IsSubset (set1.Trie, set2.Trie)
  
      /// Determines if set1 is a proper subset of set2.
      static member IsProperSubset (set1 : HashSet<'T>, set2 : HashSet<'T>) : bool =
          PatriciaHashSet.IsProperSubset (set1.Trie, set2.Trie)
  
      /// The HashSet containing the given binding.
      static member Singleton (value : 'T) : HashSet<'T> =
          let valueHash = uint32 <| hash value
  