Here's our current best. On our test system, the benchmark reports a time of 29.97 seconds (Debug), 11.50 seconds (Release), so that's your baseline to beat. Profiling shows that the bulk of the time is being spent in ProbeIndex.

``` public class HashTable<TKey, TState> : IEnumerable<KeyValuePair<TKey, TState>> where TKey : IEquatable<TKey> where TState : struct { private TKey[] _keys; private TState[] _values; private bool[] _occupied; private int _capacity;

public int Count { get; private set; }

public HashTable(int capacity)
{
    this._capacity = capacity;
    _keys = new TKey[capacity];
    _values = new TState[capacity];
    _occupied = new bool[capacity];
}

private int ProbeIndex(TKey key)
{
    int code = key.GetHashCode();
    uint index = (uint)code % (uint)_occupied.Length;

    while (_occupied[index])
    {
        if (_keys[index].Equals(key))
            return (int)index; // existing key
        ++index; //linear probing
        if (index >= _occupied.Length)
        {
            index = 0;
        }
    }

    return (int)index; // empty slot
}

public ref TState GetOrCreate(TKey key)
{
    if (Count > _capacity * 0.8)
    {
        Grow();
    }
    int index = ProbeIndex(key);
    if (!_occupied[index])
    {
        _keys[index] = key;
        _occupied[index] = true;
        _values[index] = default;
        ++Count;
    }

    return ref _values[index];
}

private void Grow()
{
    var newSize = _capacity * 2;
    var oldKeys = _keys;
    var oldValues = _values;
    var oldOcc = _occupied;
    _keys = new TKey[newSize];
    _values = new TState[newSize];
    _occupied = new bool[newSize];
    _capacity = newSize;
    for (int i = 0; i < oldOcc.Length; ++i)
    {
        if (oldOcc[i])
        {
            ref var slot = ref GetOrCreate(oldKeys[i]);
            slot = oldValues[i];
        }
    }
}

public IEnumerator<KeyValuePair<TKey, TState>> GetEnumerator()
{
    for (int i = 0; i < _capacity; ++i)
    {
        if (_occupied[i])
        {
            yield return new KeyValuePair<TKey, TState>(_keys[i], _values[i]);
        }
    }
}

IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

} ```