Многопоточный геттер System.IndexOutOfRangeException - C#

    public static class Random
    {
        // 4 Mb Random bytes buffer 
        private static byte[] seedArr = new byte[4194304];
        private static Thread waiter;
        private static long _next;
        private static long next
        {
            get
            {
                if (_next >= seedArr.LongLength && waiter == null)
                {
                    waiter = new Thread(() => Seed(0));
                    waiter.Start();
                    waiter.Join();
                    waiter = null;
                    _next = 0;
                }
                while (_next >= seedArr.LongLength)
                {
                    if (waiter != null && waiter.ThreadState == ThreadState.Running)
                    {
                        waiter.Join();
                    }
                    Thread.SpinWait(1);
                }
                return _next;
            }
            set
            {
                _next = value;
            }
        }
        public static void Seed(ulong Seed)
        {
            if (Seed.GetType() != typeof(ulong) || Seed <= 0)
            {
                RNGCryptoServiceProvider CSP = new RNGCryptoServiceProvider();
                byte[] bytes = new byte[8];
                CSP.GetNonZeroBytes(bytes);
                CSP.Dispose();
                Seed = BitConverter.ToUInt64(bytes, 0);
            }
            {
                ulong[] ticks = new ulong[4] {
                    ulong.MaxValue,
                    Convert.ToUInt64(DateTime.UtcNow.Ticks),
                    Convert.ToUInt64(Environment.TickCount),
                    Convert.ToUInt64(Thread.CurrentThread.ManagedThreadId)
                };
                ulong[] modules_a = new ulong[4] {
                    ticks[0] / ticks[1],
                    ticks[0] % ticks[1],
                    ticks[0] / ticks[2],
                    ticks[0] % ticks[2]
                };
                byte[] bytes = new byte[8];
                {
                    byte[] bytes_t = new byte[524288];
                    {
                        byte[] sbytes = BitConverter.GetBytes(Seed);
                        MemoryStream bytebuff = new MemoryStream();
                        bytebuff.Write(sbytes, 0, sbytes.Length);
                        Extensions.ParallelFor(1, 4, i =>
                        {
                            byte[] tbytes = BitConverter.GetBytes(ticks[i]);
                            lock (bytebuff)
                            {
                                bytebuff.Write(tbytes, 0, tbytes.Length);
                            }
                        });
                        Extensions.ParallelFor(0, 4, i =>
                        {
                            byte[] mbytes = BitConverter.GetBytes(modules_a[i]);
                            lock (bytebuff)
                            {
                                bytebuff.Write(mbytes, 0 , mbytes.Length);
                            }
                        });
                        byte[] seedb = bytebuff.ToArray();
                        bytebuff.Dispose();
                        {
                            byte[] rseedb = seedb;
                            rseedb.Reverse();
                            int sl = seedb.Length, rsl = rseedb.Length;
                            MemoryStream buff = new MemoryStream();
                            buff.Write(seedb, 0, sl);
                            buff.Write(rseedb, 0, rsl);
                            for (int i = 0; i < 2; i++)
                            {
                                rseedb = buff.ToArray();
                                buff.Write(rseedb, 0, rseedb.Length);
                            }
                            seedb = buff.ToArray();
                            buff.Dispose();
                        }
 
                        RNGCryptoServiceProvider CSP = new RNGCryptoServiceProvider();
                        HMACMD5 hmacmd5 = new HMACMD5(seedb);
                        HMACSHA512 hmacsha512 = new HMACSHA512(seedb);
                        CSP.GetNonZeroBytes(bytes_t);
                        byte[] md5 = hmacmd5.ComputeHash(bytes_t, 0, bytes_t.Length), sha512 = hmacsha512.ComputeHash(bytes_t, 0, bytes_t.Length);
                        CSP.Dispose();
                        hmacmd5.Dispose();
                        hmacsha512.Dispose();
 
                        long md5l = md5.LongLength, sha512l = sha512.LongLength;
                        // for (int i = 0, l = bytes_t.Length, pos = 0; i < l; i++)
                        Extensions.ParallelFor(0, bytes_t.LongLength, i =>
                        {
                            long posmd5 = i % md5l, possha512 = i % sha512l;
                            bytes_t[i] ^= md5[posmd5];
                            bytes_t[i] ^= sha512[possha512];
                        });
                        md5 = null;
                        sha512 = null;
                    }
                    Extensions.ParallelFor(0, bytes_t.LongLength, i =>
                    {
                        long pos = i % 8;
                        lock (bytes)
                        {
                            bytes[pos] ^= bytes_t[i];
                        }
                    });
                    bytes_t = null;
                }
                ulong modules = Convert.ToUInt64(Seed) ^ BitConverter.ToUInt64(bytes, 0), modules_x = 0, modules_t = 0, modules_xt = 0;
                modules_x = modules_a[0] ^ modules_a[1] ^ modules_a[2] ^ modules_a[3];
                modules_t = modules_x >> 1;
                modules_t = modules_x % modules_t;
                modules_t = modules_x ^ modules_t;
                ticks[1] ^= ticks[3];
                modules_xt = ticks[1] % modules_t;
                modules = modules ^ modules_t ^ modules_xt;
                Seed = modules;
            }
            {
                RNGCryptoServiceProvider CSP = new RNGCryptoServiceProvider();
                CSP.GetNonZeroBytes(seedArr);
                CSP.Dispose();
                byte[] bytes = BitConverter.GetBytes(Seed);
                Extensions.ParallelFor(0, seedArr.LongLength, i =>
                {
                    long pos = i % 8;
                    lock (seedArr)
                    {
                        seedArr[i] ^= bytes[pos];
                    }
                });
            }
            Seed = 0;
        }
        private static byte GetByte()
        {
            byte retbyte;
            retbyte = seedArr[next]; // Здесь System.IndexOutOfRangeException
            next++;
            return retbyte;
        }
        public static byte[] NextBytes(ulong count = 1)
        {
            byte[] bytes = new byte[count];
            // for (int i = 0; i < count; i++)
            Extensions.ParallelFor(0, bytes.LongLength, i =>
            {
                byte lbyte = GetByte();
                bytes[i] = lbyte;
            });
            return bytes;
        }
}