/// <summary>
/// 泊松盘采样等距离坐标点
/// </summary>
/// <param name="width">采样区域宽度</param>
/// <param name="height">采样区域高度</param>
/// <param name="minDistance">采样点之间最小间隔</param>
/// <param name="selectPointCount">采样点数量</param>
/// <param name="firstPoint">采样起始点</param>
/// <param name="k">单次采样迭代次数</param>
/// <returns>采样点列表</returns>
public static List<Vector2> PossionDiskSample(float width, float height, float minDistance, int selectPointCount, Vector2 firstPoint = default, int k = 10)
{
    var results = new List<Vector2>(selectPointCount);
    var processPoints = new List<Vector2>();
    float cellSize = minDistance / (float)Math.Sqrt(2);

    int col = Mathf.CeilToInt(width / cellSize);
    int row = Mathf.CeilToInt(height / cellSize);
    
    var grid = new Vector2[col, row];

    results.Add(firstPoint);
    processPoints.Add(firstPoint);
    var xy = Point2ColRow(firstPoint, cellSize);
    grid[xy.col, xy.row] = firstPoint;

    while(processPoints.Count > 0 && results.Count < selectPointCount)
    {
        var curPoint = processPoints.PickRandomElement();
        for(int i = 0;i < k; ++i)
        {
            var newPoint = NextRandomPoint(curPoint, minDistance);
            if(IsValidPossionPoint(newPoint, grid, cellSize, minDistance))
            {
                results.Add(newPoint);
                processPoints.Add(newPoint);
                var col_row = Point2ColRow(newPoint, cellSize);
                grid[col_row.col, col_row.row] = newPoint;
                if (results.Count >= selectPointCount)
                    break;
            }
        }
    }
    return results;
}

//坐标位置转换为网格索引
private static (int col, int row) Point2ColRow(Vector2 point, float cellSize)
{
    int col = Mathf.FloorToInt(point.x / cellSize);
    int row = Mathf.FloorToInt(point.y / cellSize);
    return (col, row);
}

private static Vector2 NextRandomPoint(Vector2 curPoint, float minDistance)
{
    float angle = GameRand.InclusiveRange(0, 360);
    float radius = GameRand.Range(minDistance, 2 * minDistance);
    float x = curPoint.x + radius * Mathf.Cos(angle);
    float y = curPoint.y + radius * Mathf.Sin(angle);
    return new Vector2(x, y);
}

private static bool IsValidPossionPoint(Vector2 point, Vector2[,] grid, float cellSize, float radius)
{
    var xy = Point2ColRow(point, cellSize);
    int xmax = grid.GetLength(0);
    int yMax = grid.GetLength(1);
    //不在范围内
    if (xy.col < 0 || xy.row < 0 || xy.col >= xmax || xy.row >= yMax)
        return false;
    //与邻近点过近
    for (int i = xy.col - 1; i <= xy.col + 1; ++i)
    {
        for (int j = xy.row - 1; j <= xy.row + 1; ++j)
        {
            if (i < 0 || j < 0 || i >= xmax || j >= yMax)
                continue;
            if (grid[i, j] == Vector2.zero)
                continue;
            if (Vector2.Distance(point, grid[i, j]) < radius)
                return false;
        }
    }
    return true;
}

public static T PickRandomElement<T>(this ICollection<T> elementSet, bool removePicked = true, System.Random rand = null)
{
    T res = default(T);
    if (elementSet == null || elementSet.Count == 0)
    {
        Debug.LogError("Null or Empty Collections");
        return res;
    }
    var randomIdx = -1;
    if (rand == null)
        randomIdx = UnityEngine.Random.Range(0, elementSet.Count);
    else
        randomIdx = rand.Next(0, elementSet.Count);
    res = elementSet.ElementAt(randomIdx);
    if (removePicked)
    {
        elementSet.Remove(res);
    }
    return res;
}

public static AssetBundleManifest BuildAssetBundles(string outputPath, AssetBundleBuild[] builds, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform);

public static AssetBundleManifest BuildAssetBundles(string outputPath, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform);

private string[] GetValidAssetPathsInBundle(string bundle)
{
    var results = AssetDatabase.GetAssetPathsFromAssetBundle(bundle).
        Where(assetPath => Path.GetExtension(assetPath) != ".cs").ToArray();
    return results;
}

public SortedList() {
    keys = emptyKeys;
    values = emptyValues;
    _size = 0;
    comparer = Comparer<TKey>.Default; 
}

public SortedList(int capacity) {
    if (capacity < 0)
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNumRequired);
    keys = new TKey[capacity];
    values = new TValue[capacity];
    comparer = Comparer<TKey>.Default;
}

public SortedList(IComparer<TKey> comparer) 
    : this() {
    if (comparer != null) {
        this.comparer = comparer;
    }                
}

public SortedList(int capacity, IComparer<TKey> comparer) 
    : this(comparer) {
    Capacity = capacity;
}

public SortedList(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer) 
    : this((dictionary != null ? dictionary.Count : 0), comparer) {
    if (dictionary==null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
 
    dictionary.Keys.CopyTo(keys, 0);
    dictionary.Values.CopyTo(values, 0);
    Array.Sort<TKey, TValue>(keys, values, comparer);
    _size = dictionary.Count;            
}

public SortedList(IDictionary<TKey, TValue> dictionary) 
    : this(dictionary, null) {
}

private void EnsureCapacity(int min) {
    int newCapacity = keys.Length == 0? _defaultCapacity: keys.Length * 2;
    // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow.
    // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
    if ((uint)newCapacity > MaxArrayLength) newCapacity = MaxArrayLength;
    if (newCapacity < min) newCapacity = min;
    Capacity = newCapacity;
}

public int IndexOf(TKey key) {
    if (((Object) key) == null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    
    int i = Array.BinarySearch<TKey>(_dict.keys, 0,
                              _dict.Count, key, _dict.comparer);
    if (i >= 0) return i;
    return -1;
}

public bool ContainsKey(TKey key) {
    return IndexOfKey(key) >= 0;
}
    
public bool ContainsValue(TValue value) {
    return IndexOfValue(value) >= 0;
}

private TKey GetKey(int index) {
    if (index < 0 || index >= _size) 
       ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
    return keys[index];
}

public TValue this[TKey key] {
    get {
        int i = IndexOfKey(key);
        if (i >= 0)
            return values[i];
 
        ThrowHelper.ThrowKeyNotFoundException();
        return default(TValue);
    }
    set {
        if (((Object) key) == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
        int i = Array.BinarySearch<TKey>(keys, 0, _size, key, comparer);
        if (i >= 0) {
            values[i] = value;
            version++;
            return;
        }
        Insert(~i, key, value);
    }
}

private void Insert(int index, TKey key, TValue value) {
    if (_size == keys.Length) EnsureCapacity(_size + 1);
    if (index < _size) {
        Array.Copy(keys, index, keys, index + 1, _size - index);
        Array.Copy(values, index, values, index + 1, _size - index);
    }
    keys[index] = key;
    values[index] = value;
    _size++;
    version++;
}        

public void RemoveAt(int index) {
    if (index < 0 || index >= _size) ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
    _size--;
    if (index < _size) {
        Array.Copy(keys, index + 1, keys, index, _size - index);
        Array.Copy(values, index + 1, values, index, _size - index);
    }
    keys[_size] = default(TKey);
    values[_size] = default(TValue);
    version++;
}
    

public bool Remove(TKey key) {
    int i = IndexOfKey(key);
    if (i >= 0) 
        RemoveAt(i);
    return i >= 0;
}

public void TrimExcess() {
    int threshold = (int)(((double)keys.Length) * 0.9);             
    if( _size < threshold ) {
        Capacity = _size;                
    }
}

public Queue(int capacity) {
    if (capacity < 0)
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNumRequired);
    
    _array = new T[capacity];
    _head = 0;
    _tail = 0;
    _size = 0;
}

public Queue(IEnumerable<T> collection)
{
    if (collection == null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
 
    _array = new T[_DefaultCapacity];
    _size = 0;
    _version = 0;
 
    using(IEnumerator<T> en = collection.GetEnumerator()) {
        while(en.MoveNext()) {
            Enqueue(en.Current);
        }
    }            
}

if (_size == _array.Length) {
    int newcapacity = (int)((long)_array.Length * (long)_GrowFactor / 100);
    if (newcapacity < _array.Length + _MinimumGrow) {
        newcapacity = _array.Length + _MinimumGrow;
    }
    SetCapacity(newcapacity);
}

 private void SetCapacity(int capacity) {
    T[] newarray = new T[capacity];
    if (_size > 0) {
        if (_head < _tail) {
            Array.Copy(_array, _head, newarray, 0, _size);
        } else {
            Array.Copy(_array, _head, newarray, 0, _array.Length - _head);
            Array.Copy(_array, 0, newarray, _array.Length - _head, _tail);
        }
    }
    
    _array = newarray;
    _head = 0;
    _tail = (_size == capacity) ? 0 : _size;
    _version++;
}

public void Enqueue(T item) {
    if (_size == _array.Length) {
        int newcapacity = (int)((long)_array.Length * (long)_GrowFactor / 100);
        if (newcapacity < _array.Length + _MinimumGrow) {
            newcapacity = _array.Length + _MinimumGrow;
        }
        SetCapacity(newcapacity);
    }
    
    _array[_tail] = item;
    _tail = (_tail + 1) % _array.Length;
    _size++;
    _version++;
}

public T Dequeue() {
    if (_size == 0)
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyQueue);
    
    T removed = _array[_head];
    _array[_head] = default(T);
    _head = (_head + 1) % _array.Length;
    _size--;
    _version++;
    return removed;
}

public T Peek() {
    if (_size == 0)
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyQueue);
    
    return _array[_head];
}

public bool Contains(T item) {
     int index = _head;
     int count = _size;
 
     EqualityComparer<T> c = EqualityComparer<T>.Default;
     while (count-- > 0) {
         if (((Object) item) == null) {
             if (((Object) _array[index]) == null)
                 return true;
         } 
         else if (_array[index] != null && c.Equals(_array[index], item)) {
             return true;
         }
         index = (index + 1) % _array.Length;
     }
    
     return false;
 }  

Queue<int> q = new Queue<int>(new[] { 1, 2, 3, 4, 5, 6 });

q.Dequeue();

q.Enqueue(7);

public Stack() {
    _array = _emptyArray;
    _size = 0;
    _version = 0;
}
    
public Stack(int capacity) {
    if (capacity < 0)
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNumRequired);
    _array = new T[capacity];
    _size = 0;
    _version = 0;
}
    
public Stack(IEnumerable<T> collection) 
{
    if (collection==null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
 
    ICollection<T> c = collection as ICollection<T>;
    if( c != null) {
        int count = c.Count;
        _array = new T[count];
        c.CopyTo(_array, 0);  
        _size = count;
    }    
    else {                
        _size = 0;
        _array = new T[_defaultCapacity];                    
        
        using(IEnumerator<T> en = collection.GetEnumerator()) {
            while(en.MoveNext()) {
                Push(en.Current);                                    
            }
        }
    }
}

if (_size == _array.Length) {
    T[] newArray = new T[(_array.Length == 0) ? _defaultCapacity : 2*_array.Length];
    Array.Copy(_array, 0, newArray, 0, _size);
    _array = newArray;
}

public void Push(T item) {
    if (_size == _array.Length) {
        T[] newArray = new T[(_array.Length == 0) ? _defaultCapacity : 2*_array.Length];
        Array.Copy(_array, 0, newArray, 0, _size);
        _array = newArray;
    }
    _array[_size++] = item;
    _version++;
}

public T Pop() {
    if (_size == 0)
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyStack);
    _version++;
    T item = _array[--_size];
    _array[_size] = default(T);     // Free memory quicker.
    return item;
}

public T Peek() {
    if (_size==0)
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyStack);
    return _array[_size-1];
}

public bool Contains(T item) {
    int count = _size;
 
    EqualityComparer<T> c = EqualityComparer<T>.Default;
    while (count-- > 0) {
        if (((Object) item) == null) {
            if (((Object) _array[count]) == null)
                return true;
        }
        else if (_array[count] != null && c.Equals(_array[count], item) ) {
            return true;
        }
    }
    return false;
}

public void Clear() {
    Array.Clear(_array, 0, _size);
    _size = 0;
    _version++;
}

public void TrimExcess() {
    int threshold = (int)(((double)_array.Length) * 0.9);        
    if( _size < threshold ) {
        T[] newarray = new T[_size];
        Array.Copy(_array, 0, newarray, 0, _size);    
        _array = newarray;
        _version++;
    }
}   

internal struct Slot {
    internal int hashCode;      // Lower 31 bits of hash code, -1 if unused
    internal int next;          // Index of next entry, -1 if last
    internal T value;
}

public HashSet()
    : this(EqualityComparer<T>.Default) { }
 
public HashSet(int capacity)
    : this(capacity, EqualityComparer<T>.Default) { }
 
public HashSet(IEqualityComparer<T> comparer) {
    if (comparer == null) {
        comparer = EqualityComparer<T>.Default;
    }
 
    this.m_comparer = comparer;
    m_lastIndex = 0;
    m_count = 0;
    m_freeList = -1;
    m_version = 0;
}
 
public HashSet(IEnumerable<T> collection)
    : this(collection, EqualityComparer<T>.Default) { }
 
/// <summary>
/// Implementation Notes:
/// Since resizes are relatively expensive (require rehashing), this attempts to minimize 
/// the need to resize by setting the initial capacity based on size of collection. 
/// </summary>
/// <param name="collection"></param>
/// <param name="comparer"></param>
public HashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
    : this(comparer) {
    if (collection == null) {
        throw new ArgumentNullException("collection");
    }
    Contract.EndContractBlock();
 
    var otherAsHashSet = collection as HashSet<T>;
    if (otherAsHashSet != null && AreEqualityComparersEqual(this, otherAsHashSet)) {
        CopyFrom(otherAsHashSet);
    }
    else {
        // to avoid excess resizes, first set size based on collection's count. Collection
        // may contain duplicates, so call TrimExcess if resulting hashset is larger than
        // threshold
        ICollection<T> coll = collection as ICollection<T>;
        int suggestedCapacity = coll == null ? 0 : coll.Count;
        Initialize(suggestedCapacity);
 
        this.UnionWith(collection);
 
        if (m_count > 0 && m_slots.Length / m_count > ShrinkThreshold) {
            TrimExcess();
        }
    }
}
 
// Initializes the HashSet from another HashSet with the same element type and
// equality comparer.
private void CopyFrom(HashSet<T> source) {
    int count = source.m_count;
    if (count == 0) {
        // As well as short-circuiting on the rest of the work done,
        // this avoids errors from trying to access otherAsHashSet.m_buckets
        // or otherAsHashSet.m_slots when they aren't initialized.
        return;
    }
 
    int capacity = source.m_buckets.Length;
    int threshold = HashHelpers.ExpandPrime(count + 1);
    // 将[被拷贝的hashset元素数量]最优素数大小的容量与当前hashset容量比较
    if (threshold >= capacity) {
        //当前容量更小就完全按照目标hashset大小容量拷贝
        m_buckets = (int[])source.m_buckets.Clone();
        m_slots = (Slot[])source.m_slots.Clone();
 
        m_lastIndex = source.m_lastIndex;
        m_freeList = source.m_freeList;
    }
    else {
        //当前容量更大就遍历被拷贝的hashset来一个个添加
        int lastIndex = source.m_lastIndex;
        Slot[] slots = source.m_slots;
        Initialize(count);
        int index = 0;
        for (int i = 0; i < lastIndex; ++i)
        {
            int hashCode = slots[i].hashCode;
            if (hashCode >= 0)
            {
                AddValue(index, hashCode, slots[i].value);
                ++index;
            }
        }
        Debug.Assert(index == count);
        m_lastIndex = index;
    }
    m_count = count;
}
 
public HashSet(int capacity, IEqualityComparer<T> comparer)
    : this(comparer)
{
    if (capacity < 0)
    {
        throw new ArgumentOutOfRangeException("capacity");
    }
    Contract.EndContractBlock();
 
    if (capacity > 0)
    {
        Initialize(capacity);
    }
}

ICollection<T> coll = collection as ICollection<T>;
int suggestedCapacity = coll == null ? 0 : coll.Count;
Initialize(suggestedCapacity);

if (m_count > 0 && m_slots.Length / m_count > ShrinkThreshold) {
    TrimExcess();
}

private void IncreaseCapacity() {
    Debug.Assert(m_buckets != null, "IncreaseCapacity called on a set with no elements");
 
    int newSize = HashHelpers.ExpandPrime(m_count);
    if (newSize <= m_count) {
        throw new ArgumentException(SR.GetString(SR.Arg_HSCapacityOverflow));
    }
 
    // Able to increase capacity; copy elements to larger array and rehash
    SetCapacity(newSize, false);
}
 
/// <summary>
/// Set the underlying buckets array to size newSize and rehash.  Note that newSize
/// *must* be a prime.  It is very likely that you want to call IncreaseCapacity()
/// instead of this method.
/// </summary>
private void SetCapacity(int newSize, bool forceNewHashCodes) { 
    Contract.Assert(HashHelpers.IsPrime(newSize), "New size is not prime!");
 
    Contract.Assert(m_buckets != null, "SetCapacity called on a set with no elements");
 
    Slot[] newSlots = new Slot[newSize];
    if (m_slots != null) {
        Array.Copy(m_slots, 0, newSlots, 0, m_lastIndex);
    }
 
    if(forceNewHashCodes) {
        for(int i = 0; i < m_lastIndex; i++) {
            if(newSlots[i].hashCode != -1) {
                newSlots[i].hashCode = InternalGetHashCode(newSlots[i].value);
            }
        }
    }
 
    int[] newBuckets = new int[newSize];
    for (int i = 0; i < m_lastIndex; i++) {
        int bucket = newSlots[i].hashCode % newSize;
        newSlots[i].next = newBuckets[bucket] - 1;
        newBuckets[bucket] = i + 1;
    }
    m_slots = newSlots;
    m_buckets = newBuckets;
}

public void UnionWith(IEnumerable<T> other) {
    if (other == null) {
        throw new ArgumentNullException("other");
    }
    Contract.EndContractBlock();
 
    foreach (T item in other) {
        AddIfNotPresent(item);
    }
}

public void IntersectWith(IEnumerable<T> other) {
    if (other == null) {
        throw new ArgumentNullException("other");
    }
    Contract.EndContractBlock();
 
    // intersection of anything with empty set is empty set, so return if count is 0
    if (m_count == 0) {
        return;
    }
 
    // if other is empty, intersection is empty set; remove all elements and we're done
    // can only figure this out if implements ICollection<T>. (IEnumerable<T> has no count)
    ICollection<T> otherAsCollection = other as ICollection<T>;
    if (otherAsCollection != null) {
        if (otherAsCollection.Count == 0) {
            Clear();
            return;
        }
 
        HashSet<T> otherAsSet = other as HashSet<T>;
        // faster if other is a hashset using same equality comparer; so check 
        // that other is a hashset using the same equality comparer.
        if (otherAsSet != null && AreEqualityComparersEqual(this, otherAsSet)) {
            IntersectWithHashSetWithSameEC(otherAsSet);
            return;
        }
    }
 
    IntersectWithEnumerable(other);
}

int intArrayLength = BitHelper.ToIntArrayLength(originalLastIndex);
BitHelper bitHelper;
if (intArrayLength <= StackAllocThreshold) {
    int* bitArrayPtr = stackalloc int[intArrayLength];
    bitHelper = new BitHelper(bitArrayPtr, intArrayLength);
}

internal static int ToIntArrayLength(int n) {
    return n > 0 ? ((n - 1) / IntSize + 1) : 0;
}

unsafe internal class BitHelper {   // should not be serialized
 
    private const byte MarkedBitFlag = 1;
    private const byte IntSize = 32;
 
    // m_length of underlying int array (not logical bit array)
    private int m_length;
    
    // ptr to stack alloc'd array of ints
    [System.Security.SecurityCritical]
    private int* m_arrayPtr;
 
    // array of ints
    private int[] m_array;
 
    // whether to operate on stack alloc'd or heap alloc'd array 
    private bool useStackAlloc;
 
    /// <summary>
    /// Instantiates a BitHelper with a heap alloc'd array of ints
    /// </summary>
    /// <param name="bitArray">int array to hold bits</param>
    /// <param name="length">length of int array</param>
    [System.Security.SecurityCritical]
    internal BitHelper(int* bitArrayPtr, int length) {
        this.m_arrayPtr = bitArrayPtr;
        this.m_length = length;
        useStackAlloc = true;
    }
 
    /// <summary>
    /// Instantiates a BitHelper with a heap alloc'd array of ints
    /// </summary>
    /// <param name="bitArray">int array to hold bits</param>
    /// <param name="length">length of int array</param>
    internal BitHelper(int[] bitArray, int length) {
        this.m_array = bitArray;
        this.m_length = length;
    }
 
    /// <summary>
    /// Mark bit at specified position
    /// </summary>
    /// <param name="bitPosition"></param>
    [System.Security.SecuritySafeCritical]
    internal unsafe void MarkBit(int bitPosition) {
        if (useStackAlloc) {
            int bitArrayIndex = bitPosition / IntSize;
            if (bitArrayIndex < m_length && bitArrayIndex >= 0) {
                m_arrayPtr[bitArrayIndex] |= (MarkedBitFlag << (bitPosition % IntSize));
            }
        }
        else {
            int bitArrayIndex = bitPosition / IntSize;
            if (bitArrayIndex < m_length && bitArrayIndex >= 0) {
                m_array[bitArrayIndex] |= (MarkedBitFlag << (bitPosition % IntSize));
            }
        }
    }
 
    /// <summary>
    /// Is bit at specified position marked?
    /// </summary>
    /// <param name="bitPosition"></param>
    /// <returns></returns>
    [System.Security.SecuritySafeCritical]
    internal unsafe bool IsMarked(int bitPosition) {
        if (useStackAlloc) {
            int bitArrayIndex = bitPosition / IntSize;
            if (bitArrayIndex < m_length && bitArrayIndex >= 0) {
                return ((m_arrayPtr[bitArrayIndex] & (MarkedBitFlag << (bitPosition % IntSize))) != 0);
            }
            return false;
        }
        else {
            int bitArrayIndex = bitPosition / IntSize;
            if (bitArrayIndex < m_length && bitArrayIndex >= 0) {
                return ((m_array[bitArrayIndex] & (MarkedBitFlag << (bitPosition % IntSize))) != 0);
            }
            return false;
        }
    }
 
    /// <summary>
    /// How many ints must be allocated to represent n bits. Returns (n+31)/32, but 
    /// avoids overflow
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    internal static int ToIntArrayLength(int n) {
        return n > 0 ? ((n - 1) / IntSize + 1) : 0;
    }
}

public void ExceptWith(IEnumerable<T> other) {
    if (other == null) {
        throw new ArgumentNullException("other");
    }
    Contract.EndContractBlock();
 
    // this is already the enpty set; return
    if (m_count == 0) {
        return;
    }
 
    // special case if other is this; a set minus itself is the empty set
    if (other == this) {
        Clear();
        return;
    }
 
    // remove every element in other from this
    foreach (T element in other) {
        Remove(element);
    }
}

public void SymmetricExceptWith(IEnumerable<T> other) {
    if (other == null) {
        throw new ArgumentNullException("other");
    }
    Contract.EndContractBlock();
 
    // if set is empty, then symmetric difference is other
    if (m_count == 0) {
        UnionWith(other);
        return;
    }
 
    // special case this; the symmetric difference of a set with itself is the empty set
    if (other == this) {
        Clear();
        return;
    }
 
    HashSet<T> otherAsSet = other as HashSet<T>;
    // If other is a HashSet, it has unique elements according to its equality comparer,
    // but if they're using different equality comparers, then assumption of uniqueness
    // will fail. So first check if other is a hashset using the same equality comparer;
    // symmetric except is a lot faster and avoids bit array allocations if we can assume
    // uniqueness
    if (otherAsSet != null && AreEqualityComparersEqual(this, otherAsSet)) {
        SymmetricExceptWithUniqueHashSet(otherAsSet);
    }
    else {
        SymmetricExceptWithEnumerable(other);
    }
}