anchor.diff:      let inline singleton (value : 'T) : HashSet<'T> =
           HashSet.Singleton value
   
  -    /// Tests if an element is in the domain of the set.
  -    [<CompiledName("ContainsKey")>]
  -    let inline contains (value : 'T) (set : HashSet<'T>) : bool =
  -        // Preconditions
  -        checkNonNull "set" set
  -
  -        set.Contains value
  -
  -    /// Returns the key of the first element in the collection which satisfies the given
  -    /// predicate. Returns None if no such element is found.
  -    [<CompiledName("TryFind")>]
  -    let inline tryFind (predicate : 'T -> bool) (set : HashSet<'T>) : 'T option =
  -        // Preconditions
  -        checkNonNull "set" set
  -        
  -        set.TryFind predicate
  -
  -    //
  -    [<CompiledName("Find")>]
  -    let inline find (predicate : 'T -> bool) (set : HashSet<'T>) : 'T =
  -        // Preconditions
  -        checkNonNull "set" set
  -
  -        set.Find predicate
  -
       /// Returns a new set with the binding added to this set.
       [<CompiledName("Add")>]
       let inline add (value : 'T) (set : HashSet<'T>) : HashSet<'T> =
  
positive.code:         checkNonNull "set" set
  
          set.MapPartition partitioner
  
  
negative.code: 
          set.Remove value
  
      /// Tests if an element is in the domain of the set.
      [<CompiledName("Contains")>]
      let inline contains (value : 'T) (set : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set" set
  
          set.Contains value
  
      (* maxElement, minElement *)
  
      /// Computes the union of the two sets.
      [<CompiledName("Union")>]
      let inline union (set1 : HashSet<'T>) (set2 : HashSet<'T>) : HashSet<'T> =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
          
          set1.Union set2
  
      /// Computes the union of a sequence of sets.
      [<CompiledName("UnionMany")>]
      let unionMany sets =
          // Preconditions checked by the target method.
          HashSet.UnionMany sets
  
      /// Computes the intersection of the two sets.
      [<CompiledName("Intersect")>]
      let inline intersect (set1 : HashSet<'T>) (set2 : HashSet<'T>) : HashSet<'T> =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
          
          set1.Intersect set2
  
      /// Computes the intersection of a sequence of sets.
      [<CompiledName("IntersectMany")>]
      let intersectMany sets =
          // Preconditions checked by the target method.
          HashSet.IntersectMany sets
  
      /// Returns a new set with the elements of the second set removed from the first.
      [<CompiledName("Difference")>]
      let inline difference (set1 : HashSet<'T>) (set2 : HashSet<'T>) : HashSet<'T> =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
          
          set1.Difference set2
  
      /// <summary>
      /// Evaluates to &quot;true&quot; if all elements of the first set are in the second.
      /// </summary>
      [<CompiledName("IsSubset")>]
      let inline isSubset (set1 : HashSet<'T>) (set2 : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
  
          HashSet.IsSubset (set1, set2)
  
      /// <summary>
      /// Evaluates to &quot;true&quot; if all elements of the first set are in the second,
      /// and at least one element of the second is not in the first.
      /// </summary>
      [<CompiledName("IsProperSubset")>]
      let inline isProperSubset (set1 : HashSet<'T>) (set2 : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
          
          HashSet.IsProperSubset (set1, set2)
  
      /// <summary>
      /// Evaluates to &quot;true&quot; if all elements of the second set are in the first.
      /// </summary>
      [<CompiledName("IsSuperset")>]
      let inline isSuperset (set1 : HashSet<'T>) (set2 : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
          
          HashSet.IsSubset (set2, set1)
  
      /// <summary>
      /// Evaluates to &quot;true&quot; if all elements of the second set are in the first,
      /// and at least one element of the first is not in the second.
      /// </summary>
      [<CompiledName("IsProperSuperset")>]
      let inline isProperSuperset (set1 : HashSet<'T>) (set2 : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set1" set1
          checkNonNull "set2" set2
  
          HashSet.IsProperSubset (set2, set1)
  
      /// Returns a new set made from the given bindings.
      [<CompiledName("OfSeq")>]
  