private struct Entry {
    public int hashCode;    // Lower 31 bits of hash code, -1 if unused
    public int next;        // Index of next entry, -1 if last
    public TKey key;           // Key of entry
    public TValue value;         // Value of entry
}

        public Dictionary(): this(0, null) {}
 
        public Dictionary(int capacity): this(capacity, null) {}
 
        public Dictionary(IEqualityComparer<TKey> comparer): this(0, comparer) {}
 
        public Dictionary(int capacity, IEqualityComparer<TKey> comparer) {
            if (capacity < 0) ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
            if (capacity > 0) Initialize(capacity);
            this.comparer = comparer ?? EqualityComparer<TKey>.Default;
 
#if FEATURE_CORECLR
            if (HashHelpers.s_UseRandomizedStringHashing && comparer == EqualityComparer<string>.Default)
            {
                this.comparer = (IEqualityComparer<TKey>) NonRandomizedStringEqualityComparer.Default;
            }
#endif // FEATURE_CORECLR
        }
 
        public Dictionary(IDictionary<TKey,TValue> dictionary): this(dictionary, null) {}
 
        public Dictionary(IDictionary<TKey,TValue> dictionary, IEqualityComparer<TKey> comparer):
            this(dictionary != null? dictionary.Count: 0, comparer) {
 
            if( dictionary == null) {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
            }
 
            foreach (KeyValuePair<TKey,TValue> pair in dictionary) {
                Add(pair.Key, pair.Value);
            }
        }

public Dictionary(int capacity, IEqualityComparer<TKey> comparer)

public Dictionary(IDictionary<TKey,TValue> dictionary,IEqualityComparer<TKey> comparer)

private void Resize() {
    Resize(HashHelpers.ExpandPrime(count), false);
}
 
private void Resize(int newSize, bool forceNewHashCodes) {
    Contract.Assert(newSize >= entries.Length);
    int[] newBuckets = new int[newSize];
    for (int i = 0; i < newBuckets.Length; i++) newBuckets[i] = -1;
    Entry[] newEntries = new Entry[newSize];
    Array.Copy(entries, 0, newEntries, 0, count);
    if(forceNewHashCodes) {
        for (int i = 0; i < count; i++) {
            if(newEntries[i].hashCode != -1) {
                newEntries[i].hashCode = (comparer.GetHashCode(newEntries[i].key) & 0x7FFFFFFF);
            }
        }
    }
    for (int i = 0; i < count; i++) {
        if (newEntries[i].hashCode >= 0) {
            int bucket = newEntries[i].hashCode % newSize;
            newEntries[i].next = newBuckets[bucket];
            newBuckets[bucket] = i;
        }
    }
    buckets = newBuckets;
    entries = newEntries;
}

public static readonly int[] primes = {
    3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
    1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
    17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
    187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
    1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369};

/*......Other Code......*/

// Returns size of hashtable to grow to.
public static int ExpandPrime(int oldSize)
{
    int newSize = 2 * oldSize;
 
    // Allow the hashtables to grow to maximum possible size (~2G elements) before encoutering capacity overflow.
    // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
    if ((uint)newSize > MaxPrimeArrayLength && MaxPrimeArrayLength > oldSize)
    {
        Contract.Assert( MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength), "Invalid MaxPrimeArrayLength");
        return MaxPrimeArrayLength;
    }
 
    return GetPrime(newSize);
}

public static int GetPrime(int min) 
{
    if (min < 0)
        throw new ArgumentException(Environment.GetResourceString("Arg_HTCapacityOverflow"));
    Contract.EndContractBlock();
 
    for (int i = 0; i < primes.Length; i++) 
    {
        int prime = primes[i];
        if (prime >= min) return prime;
    }
 
    //outside of our predefined table. 
    //compute the hard way. 
    for (int i = (min | 1); i < Int32.MaxValue;i+=2) 
    {
        if (IsPrime(i) && ((i - 1) % Hashtable.HashPrime != 0))
            return i;
    }
    return min;
}

if(collisionCount > HashHelpers.HashCollisionThreshold && HashHelpers.IsWellKnownEqualityComparer(comparer)) 
{
    comparer = (IEqualityComparer<TKey>) HashHelpers.GetRandomizedEqualityComparer(comparer);
    Resize(entries.Length, true);
}

var dict = new Dictionary<string,int>(5);

        private void Insert(TKey key, TValue value, bool add) {
        
            if( key == null ) {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
            }
 
            if (buckets == null) Initialize(0);
            int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
            int targetBucket = hashCode % buckets.Length;
 
#if FEATURE_RANDOMIZED_STRING_HASHING
            int collisionCount = 0;
#endif
 
            for (int i = buckets[targetBucket]; i >= 0; i = entries[i].next) {
                if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) {
                    if (add) { 
                        ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
                    }
                    entries[i].value = value;
                    version++;
                    return;
                } 
 
#if FEATURE_RANDOMIZED_STRING_HASHING
                collisionCount++;
#endif
            }
            int index;
            if (freeCount > 0) {
                index = freeList;
                freeList = entries[index].next;
                freeCount--;
            }
            else {
                if (count == entries.Length)
                {
                    Resize();
                    targetBucket = hashCode % buckets.Length;
                }
                index = count;
                count++;
            }
 
            entries[index].hashCode = hashCode;
            entries[index].next = buckets[targetBucket];
            entries[index].key = key;
            entries[index].value = value;
            buckets[targetBucket] = index;
            version++;
 
#if FEATURE_RANDOMIZED_STRING_HASHING
 
#if FEATURE_CORECLR
            // In case we hit the collision threshold we'll need to switch to the comparer which is using randomized string hashing
            // in this case will be EqualityComparer<string>.Default.
            // Note, randomized string hashing is turned on by default on coreclr so EqualityComparer<string>.Default will 
            // be using randomized string hashing
 
            if (collisionCount > HashHelpers.HashCollisionThreshold && comparer == NonRandomizedStringEqualityComparer.Default) 
            {
                comparer = (IEqualityComparer<TKey>) EqualityComparer<string>.Default;
                Resize(entries.Length, true);
            }
#else
            if(collisionCount > HashHelpers.HashCollisionThreshold && HashHelpers.IsWellKnownEqualityComparer(comparer)) 
            {
                comparer = (IEqualityComparer<TKey>) HashHelpers.GetRandomizedEqualityComparer(comparer);
                Resize(entries.Length, true);
            }
#endif // FEATURE_CORECLR
#endif
 
        }

dict.Add("A", 1);
dict.Add("B", 2);
dict.Add("C", 3);

public bool Remove(TKey key) {
    if(key == null) {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }
 
    if (buckets != null) {
        int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
        int bucket = hashCode % buckets.Length;
        int last = -1;
        for (int i = buckets[bucket]; i >= 0; last = i, i = entries[i].next) {
            if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) {
                if (last < 0) {
                    buckets[bucket] = entries[i].next;
                }
                else {
                    entries[last].next = entries[i].next;
                }
                entries[i].hashCode = -1;
                entries[i].next = freeList;
                entries[i].key = default(TKey);
                entries[i].value = default(TValue);
                freeList = i;
                freeCount++;
                version++;
                return true;
            }
        }
    }
    return false;
}

dict.Remove("A");
dict.Remove("B");

dict.Add("D", 4)

private int FindEntry(TKey key) {
            if( key == null) {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
            }
 
            if (buckets != null) {
                int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
                for (int i = buckets[hashCode % buckets.Length]; i >= 0; i = entries[i].next) {
                    if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) return i;
                }
            }
            return -1;
        }

public bool ContainsValue(TValue value) {
    if (value == null) {
        for (int i = 0; i < count; i++) {
            if (entries[i].hashCode >= 0 && entries[i].value == null) return true;
        }
    }
    else {
        EqualityComparer<TValue> c = EqualityComparer<TValue>.Default;
        for (int i = 0; i < count; i++) {
            if (entries[i].hashCode >= 0 && c.Equals(entries[i].value, value)) return true;
        }
    }
    return false;
}

   private void EnsureCapacity(int min) {
    if (_items.Length < min) {
        int newCapacity = _items.Length == 0? _defaultCapacity : _items.Length * 2;
        if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
        if (newCapacity < min) newCapacity = min;
        Capacity = newCapacity;
    }
}

 public int Capacity {
    get {
        Contract.Ensures(Contract.Result<int>() >= 0);
        return _items.Length;
    }
    set {
        if (value < _size) {
            ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);
        }
        Contract.EndContractBlock();
 
        if (value != _items.Length) {
            if (value > 0) {
                T[] newItems = new T[value];
                if (_size > 0) {
                    Array.Copy(_items, 0, newItems, 0, _size);
                }
                _items = newItems;
            }
            else {
                _items = _emptyArray;
            }
        }
    }
}

public Insert(int index, Object item)
{
   \*....*\
   if (index < _size) {
      Array.Copy(_items, index, _items, index + 1, _size - index);
   }
   \*....*\
}

   // If we're inserting a List into itself, we want to be able to deal with that.
if (this == c) {
    // Copy first part of _items to insert location
    Array.Copy(_items, 0, _items, index, index);
    // Copy last part of _items back to inserted location
    Array.Copy(_items, index + count, _items, index*2, _size-index);
}
else {
    T[] itemsToInsert = new T[count];
    c.CopyTo(itemsToInsert, 0);
    itemsToInsert.CopyTo(_items, index);                    
}

try { 
    Add((T) item);            
}
catch (InvalidCastException) { 
    ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));            
}

if (count > 0) {
   int i = _size;
   _size -= count;
   if (index < _size) {
       Array.Copy(_items, index + count, _items, index, _size - index);
   }
   Array.Clear(_items, _size, count);
   _version++;
}

public int RemoveAll(Predicate<T> match) {
      if( match == null) {
          ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
      }
      Contract.Ensures(Contract.Result<int>() >= 0);
      Contract.Ensures(Contract.Result<int>() <= Contract.OldValue(Count));
      Contract.EndContractBlock();

      int freeIndex = 0;   // the first free slot in items array

      // Find the first item which needs to be removed.
      while( freeIndex < _size && !match(_items[freeIndex])) freeIndex++;            
      if( freeIndex >= _size) return 0;
      
      int current = freeIndex + 1;
      while( current < _size) {
          // Find the first item which needs to be kept.
          while( current < _size && match(_items[current])) current++;            

          if( current < _size) {
              // copy item to the free slot.
              _items[freeIndex++] = _items[current++];
          }
      }                       
      
      Array.Clear(_items, freeIndex, _size - freeIndex);
      int result = _size - freeIndex;
      _size = freeIndex;
      _version++;
      return result;
  }

int d; 

int elapsedTimeInDays;
int daysSinceCreation;
int fileAgeInDays; 

public List<int[]> getThem()
{
    List<int[]> list1 = new List<int[]>();
    foreach(int[] x in theList)
    {
        if(x[0] == 4)
            list1.Add(cell);
    }
    return list1;
}

public List<Cell> getFlaggedCells()
{
    var flaggedCells = new List<Cell>();
    foreach(var cell in gameboard)
    {
        if(cell.isFlagged())
            flaggedCells.Add(cell);
    }
    return flaggedCells;
}

class Player
{
    private List<Weapon> m_Weapons = new List<Weapon>();

    public void AddWeapon(Weapon newWeapon)
    {
        if(m_Weapons.Count >= 5)
            return;
        m_Weapons.Add(newWeapon);
    }

    public Weapon GetWeaponAt(int idx)
    {
        if(idx < 0 || idx >= 5)
            return;
        return m_Weapons[idx];
    }
}

class Player
{
    private List<Weapon> m_Weapons = new List<Weapon>();

    private const int MAX_WEAPON_NUM = 5;

    public void AddWeapon(Weapon newWeapon)
    {
        if(m_Weapons.Count >= MAX_WEAPON_NUM)
            return;
        m_Weapons.Add(newWeapon);
    }

    public Weapon GetWeaponAt(int idx)
    {
        if(idx < 0 || idx >= MAX_WEAPON_NUM)
            return;
        return m_Weapons[idx];
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using KeyBoard.Util;
using UnityEngine.Profiling;

namespace KeyBoard.Logic.Map
{
    public abstract class IAstarNode<T> : IComparable
    {
        public float G_Value { get; set; }

        public float H_Value { get; protected set; }

        public abstract bool IsWalkable {get;}

        public float F_Value => G_Value + H_Value;

        public IAstarNode<T> Parent { get; set; }

        public T NodeData { get; private set; }

        public IAstarNode(T data)
        {
            NodeData = data;
        }

        public abstract float GetDistance(IAstarNode<T> target);


        public static bool TryFindPath<Node>(List<Node> nodes, Node start, Node end, int Width, int Length, out List<Node> path) where Node:IAstarNode<T>
        {
#if UNITY_EDITOR
            Profiler.BeginSample("CustomAstar:" + typeof(Node));
            // var watch = System.Diagnostics.Stopwatch.StartNew();
#endif
            path = null;
            if(!nodes.Contains(start) || !nodes.Contains(end))
                return false;
            if(Width < 0 || Length < 0)
                return false;
            var openNodes = new SortedSet<Node>();
            HashSet<Node> closeNodes = new HashSet<Node>();
            path = new List<Node>();
            openNodes.Add(start);
            while(openNodes.Count > 0)
            {
                var curNode = openNodes.Min;
                openNodes.Remove(curNode);
                closeNodes.Add(curNode);

                if(curNode == end) break;

                var idx = nodes.IndexOf(curNode);
                var neighbor = UIUtil.GetNeighbors(idx, (int)Width, (int)Length);
                SearchNeighbor(curNode, nodes.SafeGet(neighbor.left), end, openNodes, closeNodes);
                SearchNeighbor(curNode, nodes.SafeGet(neighbor.right), end, openNodes, closeNodes);
                SearchNeighbor(curNode, nodes.SafeGet(neighbor.up), end, openNodes, closeNodes);
                SearchNeighbor(curNode, nodes.SafeGet(neighbor.down), end, openNodes, closeNodes);
            }

            while(end != null)
            {
                path.Add(end);
                end = end.Parent as Node;
            }
#if UNITY_EDITOR
            // watch.Stop();
            // UnityEngine.Debug.Log($"自定义寻路用时{watch.ElapsedMilliseconds}ms");
            Profiler.EndSample();
#endif
            return path.Count > 0;
        }

        private static void SearchNeighbor<Node>(Node curNode, Node neighborNode, Node end, ISet<Node> openNodes, ISet<Node> closeNodes) where Node:IAstarNode<T>
        {
            if(neighborNode == null || !neighborNode.IsWalkable || closeNodes.Contains(neighborNode))
                return;
            float newCost_G = curNode.G_Value + curNode.GetDistance(neighborNode);
            if(newCost_G < neighborNode.G_Value || !openNodes.Contains(neighborNode))
            {
                neighborNode.G_Value = newCost_G;
                neighborNode.H_Value = neighborNode.GetDistance(end);
                neighborNode.Parent = curNode;
                if(!openNodes.Contains(neighborNode))
                {
                    openNodes.Add(neighborNode);
                }
            }
        }


        public int Compare(IAstarNode<T> x, IAstarNode<T> y)
        {
            if(x.H_Value < y.H_Value)
                return -1;
            if(x.H_Value > y.H_Value)
                return 1;
            return 0;
        }

        public int Compare(object x, object y)
        {
            var a = x as IAstarNode<T>;
            var b = y as IAstarNode<T>;
            if(a != null && b != null)
                return a.CompareTo(b);
            return 0;
        }

        public int CompareTo(object obj)
        {
            if (obj == null) return 1;

            var other = obj as IAstarNode<T>;
            if (other != null)
                return F_Value.CompareTo(other.F_Value);
            else
                throw new ArgumentException("Object is not an IAstarNode");
        }
    }
}

var dateTime = DateTime.Now;
Console.WriteLine(dateTime);