495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count;

494for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 530Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 539source += Vector256<byte>.Count; 541secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 543source += Vector256<byte>.Count; 551acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 556Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 634for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 639accumulators += Vector256<ulong>.Count; 640secret += Vector256<byte>.Count; 641source += Vector256<byte>.Count; 728for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 733accumulators += Vector256<ulong>.Count; 734secret += Vector256<byte>.Count;

495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count;

495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count;

205if (Vector256.IsHardwareAccelerated && Avx2.IsSupported && source.Length >= Vector256<byte>.Count) 365Debug.Assert(source.Length >= Vector256<byte>.Count); 475if (length >= Vector256<byte>.Count)

487for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 523Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 532source += Vector256<byte>.Count; 534secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 536source += Vector256<byte>.Count; 544acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 549Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 627for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 632accumulators += Vector256<ulong>.Count; 633secret += Vector256<byte>.Count; 634source += Vector256<byte>.Count; 734for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 739accumulators += Vector256<ulong>.Count; 740secret += Vector256<byte>.Count;

96if (remainder >= (uint)Vector256<T>.Count) 338Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 342if (remainder > (uint)(Vector256<T>.Count * 8)) 382misalignment = (uint)Vector256<T>.Count; 394while (remainder >= (uint)(Vector256<T>.Count * 8)) 398vector1 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 399vector2 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 400vector3 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 401vector4 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 410vector1 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 411vector2 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 412vector3 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 413vector4 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 423xPtr += (uint)(Vector256<T>.Count * 8); 425remainder -= (uint)(Vector256<T>.Count * 8); 446(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 454Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))); 461Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))); 468Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))); 475Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))); 482Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))); 489Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))); 496Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1))); 761Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 763end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 916Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 918end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1022Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1024end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1107Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1109end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1215if (remainder >= (uint)Vector256<T>.Count) 1485Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1486Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1490if (remainder > (uint)(Vector256<T>.Count * 8)) 1533misalignment = (uint)Vector256<T>.Count; 1548while (remainder >= (uint)(Vector256<T>.Count * 8)) 1552vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 1553Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 1554vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 1555Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 1556vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 1557Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 1558vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 1559Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 1568vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 1569Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 1570vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 1571Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 1572vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 1573Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 1574vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 1575Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 1585xPtr += (uint)(Vector256<T>.Count * 8); 1586yPtr += (uint)(Vector256<T>.Count * 8); 1588remainder -= (uint)(Vector256<T>.Count * 8); 1610(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 1618Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 1619Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7))); 1626Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 1627Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6))); 1634Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 1635Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5))); 1642Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 1643Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4))); 1650Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 1651Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3))); 1658Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 1659Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2))); 1666Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1)), 1667Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 1))); 1958Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1959Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1961end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2119Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2120Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2122end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2231Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2232Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2234end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2324Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2325Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2327end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue));

105if (remainder >= (uint)Vector256<T>.Count) 404Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 405Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 407if (remainder > (uint)(Vector256<T>.Count * 8)) 455while (remainder >= (uint)(Vector256<T>.Count * 8)) 459vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 460Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 461vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 462Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 463vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 464Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 465vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 466Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 468vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 469vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 470vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 471vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 475vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 476Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 477vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 478Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 479vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 480Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 481vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 482Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 484vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 485vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 486vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 487vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 492xPtr += (uint)(Vector256<T>.Count * 8); 493yPtr += (uint)(Vector256<T>.Count * 8); 494dPtr += (uint)(Vector256<T>.Count * 8); 496remainder -= (uint)(Vector256<T>.Count * 8); 501while (remainder >= (uint)(Vector256<T>.Count * 8)) 505vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 506Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 507vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 508Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 509vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 510Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 511vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 512Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 514vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 515vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 516vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 517vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 521vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 522Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 523vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 524Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 525vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 526Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 527vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 528Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 530vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 531vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 532vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 533vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 538xPtr += (uint)(Vector256<T>.Count * 8); 539yPtr += (uint)(Vector256<T>.Count * 8); 540dPtr += (uint)(Vector256<T>.Count * 8); 542remainder -= (uint)(Vector256<T>.Count * 8); 562remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 564switch (remainder / (uint)Vector256<T>.Count) 568Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 569Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8))); 570vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 576Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 577Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7))); 578vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 584Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 585Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6))); 586vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 592Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 593Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5))); 594vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 600Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 601Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4))); 602vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 608Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 609Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3))); 610vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 616Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 617Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2))); 618vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 625end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 946Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 947Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 950end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1118Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1119Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1122end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1233Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1234Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1237end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1323Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1324Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1327end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1437if (remainder >= (uint)Vector256<T>.Count) 1734Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 1737if (remainder > (uint)(Vector256<T>.Count * 8)) 1782while (remainder >= (uint)(Vector256<T>.Count * 8)) 1786vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))), 1788vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))), 1790vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))), 1792vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))), 1795vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 1796vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 1797vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 1798vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 1802vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))), 1804vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))), 1806vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))), 1808vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))), 1811vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 1812vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 1813vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 1814vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 1819xPtr += (uint)(Vector256<T>.Count * 8); 1820dPtr += (uint)(Vector256<T>.Count * 8); 1822remainder -= (uint)(Vector256<T>.Count * 8); 1827while (remainder >= (uint)(Vector256<T>.Count * 8)) 1831vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))), 1833vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))), 1835vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))), 1837vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))), 1840vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 1841vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 1842vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 1843vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 1847vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))), 1849vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))), 1851vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))), 1853vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))), 1856vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 1857vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 1858vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 1859vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 1864xPtr += (uint)(Vector256<T>.Count * 8); 1865dPtr += (uint)(Vector256<T>.Count * 8); 1867remainder -= (uint)(Vector256<T>.Count * 8); 1886remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 1888switch (remainder / (uint)Vector256<T>.Count) 1892Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8))), 1894vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 1900Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))), 1902vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 1908Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))), 1910vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 1916Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))), 1918vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 1924Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))), 1926vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 1932Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))), 1934vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 1940Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))), 1942vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 1949end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 2268Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2272end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2444Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2448end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2563Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2567end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2657Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2661end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);

113oneVectorFromEnd = x.Length - Vector256<T>.Count; 124i += Vector256<T>.Count; 130TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count))))) 250int vectorFromEnd = x.Length - Vector256<T>.Count; 257i += Vector256<T>.Count; 264i = x.Length - Vector256<T>.Count; 361int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 368i += Vector256<T>.Count * sizeof(T); 375i = x.Length - (Vector256<T>.Count * sizeof(T)); 386TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt16()); 482int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 489i += Vector256<T>.Count * sizeof(T); 496i = x.Length - (Vector256<T>.Count * sizeof(T)); 508TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt32()), 510TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector256<T>.Count)))).AsUInt32(), 511TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector256<T>.Count)))).AsUInt32())); 621int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 628i += Vector256<T>.Count * sizeof(T); 635i = x.Length - (Vector256<T>.Count * sizeof(T)); 648TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt64()), 650TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector256<T>.Count)))).AsUInt64(), 651TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector256<T>.Count)))).AsUInt64())), 654TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (4 * Vector256<T>.Count)))).AsUInt64(), 655TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (5 * Vector256<T>.Count)))).AsUInt64()), 657TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (6 * Vector256<T>.Count)))).AsUInt64(), 658TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (7 * Vector256<T>.Count)))).AsUInt64())));

39if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 335Vector256<TInt> indexIncrement = Vector256.Create(TInt.CreateTruncating(Vector256<TInt>.Count)); 338ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 343if (span.Length >= Vector256<T>.Count) 346span = span.Slice(Vector256<T>.Count); 351int start = x.Length - Vector256<T>.Count; 402Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count); 406ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 411if (span.Length >= Vector256<T>.Count) 414span = span.Slice(Vector256<T>.Count); 419int start = x.Length - Vector256<T>.Count; 477Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count); 483ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 488if (span.Length >= Vector256<T>.Count) 491span = span.Slice(Vector256<T>.Count); 496int start = x.Length - Vector256<T>.Count;

71if (remainder >= (uint)Vector256<T>.Count) 337Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 339if (remainder > (uint)(Vector256<T>.Count * 8)) 384while (remainder >= (uint)(Vector256<T>.Count * 8)) 388vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 389vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 390vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 391vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 393vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 394vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 395vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 396vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 400vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 401vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 402vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 403vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 405vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 406vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 407vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 408vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 413xPtr += (uint)(Vector256<T>.Count * 8); 414dPtr += (uint)(Vector256<T>.Count * 8); 416remainder -= (uint)(Vector256<T>.Count * 8); 421while (remainder >= (uint)(Vector256<T>.Count * 8)) 425vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 426vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 427vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 428vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 430vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 431vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 432vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 433vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 437vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 438vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 439vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 440vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 442vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 443vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 444vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 445vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 450xPtr += (uint)(Vector256<T>.Count * 8); 451dPtr += (uint)(Vector256<T>.Count * 8); 453remainder -= (uint)(Vector256<T>.Count * 8); 472remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 474switch (remainder / (uint)Vector256<T>.Count) 478Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8))); 479vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 485Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))); 486vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 492Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))); 493vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 499Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))); 500vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 506Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))); 507vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 513Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))); 514vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 520Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))); 521vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 528end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 817Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 820end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 969Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 972end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1072Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1075end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1154Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1157end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);

92if (remainder >= (uint)Vector256<T>.Count) 424Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 425Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 426Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 428if (remainder > (uint)(Vector256<T>.Count * 8)) 479while (remainder >= (uint)(Vector256<T>.Count * 8)) 483vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 484Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 485Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0))); 486vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 487Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 488Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1))); 489vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 490Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 491Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2))); 492vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 493Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 494Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3))); 496vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 497vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 498vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 499vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 503vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 504Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 505Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4))); 506vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 507Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 508Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5))); 509vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 510Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 511Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6))); 512vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 513Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 514Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7))); 516vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 517vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 518vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 519vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 524xPtr += (uint)(Vector256<T>.Count * 8); 525yPtr += (uint)(Vector256<T>.Count * 8); 526zPtr += (uint)(Vector256<T>.Count * 8); 527dPtr += (uint)(Vector256<T>.Count * 8); 529remainder -= (uint)(Vector256<T>.Count * 8); 534while (remainder >= (uint)(Vector256<T>.Count * 8)) 538vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 539Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 540Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0))); 541vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 542Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 543Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1))); 544vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 545Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 546Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2))); 547vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 548Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 549Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3))); 551vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 552vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 553vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 554vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 558vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 559Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 560Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4))); 561vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 562Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 563Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5))); 564vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 565Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 566Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6))); 567vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 568Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 569Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7))); 571vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 572vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 573vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 574vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 579xPtr += (uint)(Vector256<T>.Count * 8); 580yPtr += (uint)(Vector256<T>.Count * 8); 581zPtr += (uint)(Vector256<T>.Count * 8); 582dPtr += (uint)(Vector256<T>.Count * 8); 584remainder -= (uint)(Vector256<T>.Count * 8); 605remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 607switch (remainder / (uint)Vector256<T>.Count) 611Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 612Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)), 613Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8))); 614vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 620Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 621Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)), 622Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7))); 623vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 629Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 630Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)), 631Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6))); 632vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 638Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 639Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)), 640Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5))); 641vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 647Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 648Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)), 649Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4))); 650vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 656Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 657Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)), 658Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3))); 659vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 665Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 666Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)), 667Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2))); 668vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 675end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 1028Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1029Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1030Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1033end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1220Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1221Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1222Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1225end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1347Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1348Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1349Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1352end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1445Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1446Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1447Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1450end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1567if (remainder >= (uint)Vector256<T>.Count) 1897Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1898Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1901if (remainder > (uint)(Vector256<T>.Count * 8)) 1949while (remainder >= (uint)(Vector256<T>.Count * 8)) 1953vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 1954Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 1956vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 1957Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 1959vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 1960Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 1962vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 1963Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 1966vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 1967vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 1968vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 1969vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 1973vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 1974Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 1976vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 1977Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 1979vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 1980Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 1982vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 1983Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 1986vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 1987vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 1988vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 1989vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 1994xPtr += (uint)(Vector256<T>.Count * 8); 1995yPtr += (uint)(Vector256<T>.Count * 8); 1996dPtr += (uint)(Vector256<T>.Count * 8); 1998remainder -= (uint)(Vector256<T>.Count * 8); 2003while (remainder >= (uint)(Vector256<T>.Count * 8)) 2007vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 2008Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 2010vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 2011Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 2013vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 2014Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 2016vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 2017Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 2020vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 2021vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 2022vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 2023vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 2027vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 2028Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 2030vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 2031Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 2033vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 2034Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 2036vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 2037Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 2040vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 2041vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 2042vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 2043vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 2048xPtr += (uint)(Vector256<T>.Count * 8); 2049yPtr += (uint)(Vector256<T>.Count * 8); 2050dPtr += (uint)(Vector256<T>.Count * 8); 2052remainder -= (uint)(Vector256<T>.Count * 8); 2072remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 2074switch (remainder / (uint)Vector256<T>.Count) 2078Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 2079Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)), 2081vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 2087Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 2088Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)), 2090vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 2096Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 2097Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)), 2099vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 2105Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 2106Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)), 2108vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 2114Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 2115Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)), 2117vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 2123Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 2124Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)), 2126vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 2132Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 2133Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)), 2135vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 2142end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 2493Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2494Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2498end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2689Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2690Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2694end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2820Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2821Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2825end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2922Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2923Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2927end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 3053if (remainder >= (uint)Vector256<T>.Count) 3379Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 3383if (remainder > (uint)(Vector256<T>.Count * 8)) 3428while (remainder >= (uint)(Vector256<T>.Count * 8)) 3432vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 3435vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 3438vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 3441vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 3445vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 3446vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 3447vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 3448vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 3452vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 3455vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 3458vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 3461vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 3465vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 3466vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 3467vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 3468vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 3473xPtr += (uint)(Vector256<T>.Count * 8); 3474dPtr += (uint)(Vector256<T>.Count * 8); 3476remainder -= (uint)(Vector256<T>.Count * 8); 3481while (remainder >= (uint)(Vector256<T>.Count * 8)) 3485vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 3488vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 3491vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 3494vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 3498vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 3499vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 3500vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 3501vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 3505vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 3508vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 3511vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 3514vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 3518vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 3519vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 3520vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 3521vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 3526xPtr += (uint)(Vector256<T>.Count * 8); 3527dPtr += (uint)(Vector256<T>.Count * 8); 3529remainder -= (uint)(Vector256<T>.Count * 8); 3548remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 3550switch (remainder / (uint)Vector256<T>.Count) 3554Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 3557vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 3563Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 3566vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 3572Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 3575vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 3581Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 3584vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 3590Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 3593vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 3599Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 3602vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 3608Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 3611vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 3618end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 3965Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 3970end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4163Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4168end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4296Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4301end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4400Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4405end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);

102oneVectorFromEnd = x.Length - Vector256<T>.Count; 112i += Vector256<T>.Count; 119i = x.Length - Vector256<T>.Count; 255oneVectorFromEnd = x.Length - Vector256<T>.Count; 265i += Vector256<T>.Count; 274i = x.Length - Vector256<T>.Count; 438oneVectorFromEnd = x.Length - Vector256<T>.Count; 450i += Vector256<T>.Count; 459i = x.Length - Vector256<T>.Count;

86oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 94results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 95results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 2))); 96results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 3))); 98i += Vector256<TInput>.Count; 105i = x.Length - Vector256<TInput>.Count; 109results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 110results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 2))); 111results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 3)));

82oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 90upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 92i += Vector256<TInput>.Count; 99i = x.Length - Vector256<TInput>.Count; 103upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count));

111if (remainder >= (uint)Vector256<TInput>.Count) 377Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 379if (remainder > (uint)(Vector256<TInput>.Count * 8)) 424while (remainder >= (uint)(Vector256<TInput>.Count * 8)) 428vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0))); 429vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1))); 430vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2))); 431vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3))); 433vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 0)); 434vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 1)); 435vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 2)); 436vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 3)); 440vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4))); 441vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5))); 442vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6))); 443vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7))); 445vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 4)); 446vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 5)); 447vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 6)); 448vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 7)); 453xPtr += (uint)(Vector256<TInput>.Count * 8); 454dPtr += (uint)(Vector256<TOutput>.Count * 8); 456remainder -= (uint)(Vector256<TInput>.Count * 8); 461while (remainder >= (uint)(Vector256<TInput>.Count * 8)) 465vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0))); 466vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1))); 467vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2))); 468vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3))); 470vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 0)); 471vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 1)); 472vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 2)); 473vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 3)); 477vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4))); 478vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5))); 479vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6))); 480vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7))); 482vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 4)); 483vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 5)); 484vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 6)); 485vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 7)); 490xPtr += (uint)(Vector256<TInput>.Count * 8); 491dPtr += (uint)(Vector256<TOutput>.Count * 8); 493remainder -= (uint)(Vector256<TInput>.Count * 8); 512remainder = (remainder + (uint)(Vector256<TInput>.Count - 1)) & (nuint)(-Vector256<TInput>.Count); 514switch (remainder / (uint)Vector256<TInput>.Count) 518Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 8))); 519vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 8)); 525Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 7))); 526vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 7)); 532Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 6))); 533vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 6)); 539Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 5))); 540vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 5)); 546Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 4))); 547vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 4)); 553Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 3))); 554vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 3)); 560Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 2))); 561vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 2)); 568end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<TOutput>.Count); 857Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 860end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1009Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1012end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1112Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1115end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1194Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1197end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count);

82twoVectorsFromEnd = x.Length - (Vector256<TInput>.Count * 2); 90Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i); 92i += Vector256<TInput>.Count * 2; 99i = x.Length - (Vector256<TInput>.Count * 2); 103Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);

98if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 108int oneVectorFromEnd = x.Length - Vector256<T>.Count; 117i += Vector256<T>.Count; 127Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)) & remainderMask, 128Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count)) & remainderMask, 243if (Vector256.IsHardwareAccelerated && x.Length >= Vector256<short>.Count) 254int oneVectorFromEnd = x.Length - Vector256<short>.Count; 264i += Vector256<short>.Count; 274Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<short>.Count)) & remainderMask); 276Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<short>.Count)) & remainderMask);

77if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 116int oneVectorFromEnd = x.Length - Vector256<T>.Count; 125i += Vector256<T>.Count; 132Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 133Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count));

205if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 225int oneVectorFromEnd = x.Length - Vector256<T>.Count; 226int i = Vector256<T>.Count; 245i += Vector256<T>.Count; 251current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count));

310while (i <= source.Length - Vector256<T>.Count) 313i += Vector256<T>.Count; 342while (i >= Vector256<T>.Count) 344i -= Vector256<T>.Count;

218if (!BitConverter.IsLittleEndian || values.Length < Vector256<byte>.Count) 244while (valuesAsBytes.Length >= Vector256<byte>.Count) 251i += (uint)Vector256<byte>.Count; 252valuesAsBytes = valuesAsBytes.Slice(Vector256<byte>.Count); 862else if (Vector256.IsHardwareAccelerated && (uint)_bitLength >= Vector256<byte>.Count) 870for (; (i + Vector256<byte>.Count) <= (uint)_bitLength; i += (uint)Vector256<byte>.Count)

171if (Vector256.IsHardwareAccelerated && length >= Vector256<ushort>.Count) 456if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 462nint searchSpaceMinusValueTailLengthAndVector = searchSpaceMinusValueTailLength - (nint)Vector256<ushort>.Count; 466Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= source.Length); 481offset += Vector256<ushort>.Count;

257if (!Vector256.IsHardwareAccelerated || span.Length < Vector256<T>.Count) 274data = data.Slice(Vector256<T>.Count); 276while (data.Length > Vector256<T>.Count) 279data = data.Slice(Vector256<T>.Count); 281best = TMinMax.Compare(best, Vector256.Create(span.Slice(span.Length - Vector256<T>.Count)));

474else if (Vector<double>.Count == Vector256<double>.Count) 497else if (Vector<double>.Count == Vector256<double>.Count) 605else if (Vector<float>.Count == Vector256<float>.Count) 768else if (Vector<T>.Count == Vector256<T>.Count) 887else if (Vector<T>.Count == Vector256<T>.Count) 942else if (Vector<T>.Count == Vector256<T>.Count) 966else if (Vector<T>.Count == Vector256<T>.Count) 990else if (Vector<T>.Count == Vector256<T>.Count) 1014else if (Vector<T>.Count == Vector256<T>.Count) 1038else if (Vector<T>.Count == Vector256<T>.Count) 1062else if (Vector<T>.Count == Vector256<T>.Count) 1095else if (Vector<T>.Count == Vector256<T>.Count) 1119else if (Vector<T>.Count == Vector256<T>.Count) 1151else if (Vector<T>.Count == Vector256<T>.Count) 1705else if (Vector<T>.Count == Vector256<T>.Count) 1943else if (Vector<T>.Count == Vector256<T>.Count) 2985else if (Vector<uint>.Count == Vector256<uint>.Count) 3011else if (Vector<ulong>.Count == Vector256<ulong>.Count)

67for (int i = 0; i < Count; i++) 421for (int i = 0; i < Count; i++) 445for (int i = 1; i < Count; i++) 464static int ISimdVector<Vector256<T>, T>.ElementCount => Vector256<T>.Count;

372if (Vector<T>.Count >= Vector256<T>.Count) 396if (Vector256<T>.Count >= Vector<T>.Count) 749/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 757if (destination.Length < Vector256<T>.Count) 770/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 784if ((destination.Length - startIndex) < Vector256<T>.Count) 796/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 801if (destination.Length < Vector256<T>.Count) 1017/// <returns>A new <see cref="Vector256{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1018/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector256{T}.Count" />.</exception> 1026if (values.Length < Vector256<T>.Count) 1039/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector256{T}.Count" />.</exception> 1047if ((index < 0) || ((values.Length - index) < Vector256<T>.Count)) 1058/// <returns>A new <see cref="Vector256{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1059/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector256{T}.Count" />.</exception> 1064if (values.Length < Vector256<T>.Count) 1667for (int index = 0; index < Vector256<T>.Count; index++) 1679for (int index = 1; index < Vector256<T>.Count; index++) 2059if ((uint)(index) >= (uint)(Vector256<T>.Count)) 2986for (int i = 0; i < Vector256<TSource>.Count; i++) 2992for (int i = Vector256<TSource>.Count; i < Vector256<TResult>.Count; i++) 2994TResult value = TResult.CreateTruncating(upper.GetElementUnsafe(i - Vector256<TSource>.Count)); 3055for (int i = 0; i < Vector256<TSource>.Count; i++) 3061for (int i = Vector256<TSource>.Count; i < Vector256<TResult>.Count; i++) 3063TResult value = TResult.CreateSaturating(upper.GetElementUnsafe(i - Vector256<TSource>.Count)); 3461Debug.Assert(Vector256<T>.Count == Vector256<TIndex>.Count); 3464for (int index = 0; index < Vector256<T>.Count; index++) 3468if ((uint)selectedIndex < (uint)Vector256<T>.Count) 3900/// <returns><c>true</c> if <paramref name="vector" /> was successfully copied to <paramref name="destination" />; otherwise, <c>false</c> if the length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</returns> 3905if (destination.Length < Vector256<T>.Count) 4188if ((uint)(index) >= (uint)(Vector256<T>.Count)) 4258Debug.Assert((index >= 0) && (index < Vector256<T>.Count)); 4307Debug.Assert((index >= 0) && (index < Vector256<T>.Count));

21var items = new byte[Vector256<byte>.Count]; 31var items = new double[Vector256<double>.Count]; 41var items = new short[Vector256<short>.Count]; 51var items = new int[Vector256<int>.Count]; 61var items = new long[Vector256<long>.Count]; 71var items = new nint[Vector256<nint>.Count]; 81var items = new nuint[Vector256<nuint>.Count]; 91var items = new sbyte[Vector256<sbyte>.Count]; 101var items = new float[Vector256<float>.Count]; 111var items = new ushort[Vector256<ushort>.Count]; 121var items = new uint[Vector256<uint>.Count]; 131var items = new ulong[Vector256<ulong>.Count];

934/// <returns>A new <see cref="Vector512{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1750T upperStart = Scalar<T>.Add(start, Scalar<T>.Multiply(Scalar<T>.Convert(Vector256<T>.Count), step)); 2029result |= (ulong)(vector._upper.ExtractMostSignificantBits()) << Vector256<T>.Count; 4260return result + ((result >= 0) ? Vector256<T>.Count : 0); 4277return result + Vector256<T>.Count;

318if (searchSpaceLength > 2 * Vector256<short>.Count) 326ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector256<short>.Count)); 331Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 339currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 346Debug.Assert(searchSpaceLength >= Vector256<short>.Count, "We expect that the input is long enough for us to load a whole vector."); 348ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<short>.Count); 450if (searchSpaceLength > 2 * Vector256<short>.Count) 458ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector256<short>.Count); 462currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector256<short>.Count); 465Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 478Debug.Assert(searchSpaceLength >= Vector256<short>.Count, "We expect that the input is long enough for us to load a whole vector."); 480ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<short>.Count); 483? ref Unsafe.Subtract(ref currentSearchSpace, Vector256<short>.Count) 603if (searchSpaceLength > Vector256<byte>.Count) 609ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count); 621currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count); 728if (searchSpaceLength > Vector256<byte>.Count) 734ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 738currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count); 875if (searchSpaceLength > Vector256<byte>.Count) 881ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count); 893currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count); 1003if (searchSpaceLength > Vector256<byte>.Count) 1009ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 1013currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count); 1301if (offsetInVector < Vector256<short>.Count) 1307return offsetInVector - Vector256<short>.Count + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref secondVector) / (nuint)sizeof(T)); 1537if (offsetInVector >= Vector256<short>.Count) 1541offsetInVector -= Vector256<short>.Count;

187Vector256<ushort> source1 = Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<ushort>.Count); 494Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<ushort>.Count)); 673Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref cur, Vector256<ushort>.Count)); 816if (index >= Vector256<ushort>.Count) 820index += searchSpaceLength - (2 * Vector256<ushort>.Count); 918if (index >= Vector256<ushort>.Count) 922index += searchSpaceLength - (2 * Vector256<ushort>.Count);

259Vector256<ushort> source1 = Vector256.LoadUnsafe(ref source, (nuint)Vector256<ushort>.Count);

138else if (Vector256.IsHardwareAccelerated && Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0) 144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<byte>.Count); 148ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count); 149ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count + (int)(_ch2ByteOffset / sizeof(char))); 150ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count + (int)(_ch3ByteOffset / sizeof(char))); 161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<byte>.Count))) 408Vector256.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset + (uint)Vector256<byte>.Count)).AsInt16());

138else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<ushort>.Count); 148ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count); 149ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count + (int)(_ch2ByteOffset / sizeof(char))); 150ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count + (int)(_ch3ByteOffset / sizeof(char))); 161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<ushort>.Count); 165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<ushort>.Count)))

127else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0) 140searchSpaceMinusValueTailLength - (nint)Vector256<byte>.Count; 146Debug.Assert(offset + ch1ch2Distance + Vector256<byte>.Count <= searchSpaceLength); 159offset += Vector256<byte>.Count; 346else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<byte>.Count) 348offset = searchSpaceMinusValueTailLength - Vector256<byte>.Count; 385offset -= Vector256<byte>.Count; 386if (offset == -Vector256<byte>.Count) 524if ((((nuint)(uint)searchSpace + offset) & (nuint)(Vector256<byte>.Count - 1)) != 0) 559offset += (nuint)Vector256<byte>.Count; 598offset += (nuint)Vector256<byte>.Count; 637if ((((nuint)(uint)searchSpace + offset) & (nuint)(Vector256<byte>.Count - 1)) != 0) 671offset += (nuint)Vector256<byte>.Count; 853else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<byte>.Count) 856nuint lengthToExamine = length - (nuint)Vector256<byte>.Count; 868offset += (nuint)Vector256<byte>.Count; 1019if (lengthToExamine >= (nuint)Vector256<byte>.Count) 1021lengthToExamine -= (nuint)Vector256<byte>.Count; 1033offset += (nuint)Vector256<byte>.Count; 1286=> (nuint)(uint)((length - (int)offset) & ~(Vector256<byte>.Count - 1)); 1344else if (Avx2.IsSupported && remainder >= (nint)(Vector256<byte>.Count * 1.5)) 1350nint lastOffset = remainder - Vector256<byte>.Count; 1385offset += Vector256<byte>.Count; 1386lastOffset -= Vector256<byte>.Count; 1389remainder = lastOffset + Vector256<byte>.Count - offset;

139else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 152searchSpaceMinusValueTailLength - (nint)Vector256<ushort>.Count; 157Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= searchSpaceLength); 170offset += Vector256<ushort>.Count; 364else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<ushort>.Count) 366offset = searchSpaceMinusValueTailLength - Vector256<ushort>.Count; 406offset -= Vector256<ushort>.Count; 407if (offset == -Vector256<ushort>.Count) 587if (((nint)(searchSpace + (nint)offset) & (nint)(Vector256<byte>.Count - 1)) != 0) 633offset += Vector256<ushort>.Count; 676Debug.Assert(lengthToExamine >= Vector256<ushort>.Count); 685offset += Vector256<ushort>.Count; 731if (((nint)(searchSpace + (nint)offset) & (nint)(Vector256<byte>.Count - 1)) != 0) 764Debug.Assert(lengthToExamine >= Vector256<ushort>.Count); 773offset += Vector256<ushort>.Count; 774lengthToExamine -= Vector256<ushort>.Count; 875=> (length - offset) & ~(Vector256<ushort>.Count - 1); 930else if (Avx2.IsSupported && remainder >= (nint)(Vector256<ushort>.Count * 1.5)) 936nint lastOffset = remainder - Vector256<ushort>.Count; 967offset += Vector256<ushort>.Count; 968lastOffset -= Vector256<ushort>.Count; 971remainder = (lastOffset + Vector256<ushort>.Count - offset);

125else if (Avx2.IsSupported && remainder >= Vector256<int>.Count * 2) 127nint lastOffset = remainder - Vector256<int>.Count; 149offset += Vector256<int>.Count; 150lastOffset -= Vector256<int>.Count; 153remainder = lastOffset + Vector256<int>.Count - offset; 230else if (Avx2.IsSupported && remainder >= Vector256<long>.Count * 2) 232nint lastOffset = remainder - Vector256<long>.Count; 254offset += Vector256<long>.Count; 255lastOffset -= Vector256<long>.Count; 258remainder = lastOffset + Vector256<long>.Count - offset;

198else if (Avx2.IsSupported && length > Vector256<short>.Count) 203if (length > 2 * Vector256<short>.Count) 209ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 214Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 223currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 231ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 397else if (Avx2.IsSupported && length > Vector256<short>.Count) 402if (length > 2 * Vector256<short>.Count) 408ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 413Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 423currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 431ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 609else if (Avx2.IsSupported && length > Vector256<short>.Count) 615if (length > 2 * Vector256<short>.Count) 621ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 626Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 636currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 644ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 825else if (Avx2.IsSupported && length > Vector256<short>.Count) 832if (length > 2 * Vector256<short>.Count) 838ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 843Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 853currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 861ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 1022else if (Avx2.IsSupported && length > Vector256<short>.Count) 1028if (length > 2 * Vector256<short>.Count) 1034ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 1039Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 1049currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 1057ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 1275if (offsetInVector >= Vector256<short>.Count) 1279offsetInVector -= Vector256<short>.Count;

1558else if (Vector256.IsHardwareAccelerated && length >= Vector256<T>.Count) 1562ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count)); 1570currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<T>.Count); 1579if ((uint)length % Vector256<T>.Count != 0) 1777else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 1781ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 1789currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 1798if ((uint)length % Vector256<TValue>.Count != 0) 2041else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2045ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2054currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2063if ((uint)length % Vector256<TValue>.Count != 0) 2282else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2286ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2295currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2304if ((uint)length % Vector256<TValue>.Count != 0) 2451else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2455ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2465currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2474if ((uint)length % Vector256<TValue>.Count != 0) 2625else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2630ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<TValue>.Count)); 2640currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2649if ((uint)length % Vector256<TValue>.Count != 0) 2800else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2999else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3002nint offset = length - Vector256<TValue>.Count; 3012offset -= Vector256<TValue>.Count; 3215else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3218nint offset = length - Vector256<TValue>.Count; 3228offset -= Vector256<TValue>.Count; 3373else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3376nint offset = length - Vector256<TValue>.Count; 3386offset -= Vector256<TValue>.Count; 3470if (!Vector256.IsHardwareAccelerated || length < (uint)Vector256<T>.Count) 3500nuint lastVectorIndex = length - (uint)Vector256<T>.Count; 3512idx += (uint)Vector256<T>.Count; 3645else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3649nint offset = length - Vector256<TValue>.Count; 3659offset -= Vector256<TValue>.Count; 3901else if (!Vector256.IsHardwareAccelerated || length < Vector256<T>.Count) 3937ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count)); 3948current = ref Unsafe.Add(ref current, Vector256<T>.Count); 4048else if (!Vector256.IsHardwareAccelerated || length < Vector256<T>.Count) 4081nint offset = length - Vector256<T>.Count; 4092offset -= Vector256<T>.Count; 4188else if (Vector256.IsHardwareAccelerated && length >= Vector256<T>.Count) 4191ref T oneVectorAwayFromEnd = ref Unsafe.Subtract(ref end, Vector256<T>.Count); 4195current = ref Unsafe.Add(ref current, Vector256<T>.Count);

1326else if (Vector256.IsHardwareAccelerated && length >= (uint)Vector256<ushort>.Count) 1328nuint adjust = (length - remainingLength) & ((uint)Vector256<ushort>.Count - 1); 2222else if (Vector256.IsHardwareAccelerated && (uint)remaining.Length >= (uint)Vector256<ushort>.Count*2) 2237while ((uint)remaining.Length >= (uint)Vector256<ushort>.Count*2) 2240Vector256<ushort> vector2 = Vector256.Create(remaining.Slice(Vector256<ushort>.Count)); 2261sepListBuilder.Append(baseIndex + (int)bitPos + Vector256<ushort>.Count); 2268baseIndex += Vector256<ushort>.Count*2; 2269remaining = remaining.Slice(Vector256<ushort>.Count*2); 2274baseIndex += Vector256<ushort>.Count*2; 2275remaining = remaining.Slice(Vector256<ushort>.Count*2); 2279while ((uint)remaining.Length >= (uint)Vector256<ushort>.Count) 2296baseIndex += Vector256<ushort>.Count; 2297remaining = remaining.Slice(Vector256<ushort>.Count); 2304Vector256<ushort> vector = Vector256.Create(sourceSpanUInt16.Slice(sourceSpanUInt16.Length - Vector256<ushort>.Count)); 2306int finalIndex = sourceSpanUInt16.Length - Vector256<ushort>.Count; 2307uint mask = cmp.ExtractMostSignificantBits() & 0x55555555 & ~((1u << (Vector256<byte>.Count - remaining.Length * sizeof(char))) - 1);

119if (length <= 2 * Vector256<T>.Count) 123Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count))); 127if (length > 4 * Vector256<T>.Count) 132Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<T>.Count) | 133Vector256.LoadUnsafe(ref searchSpace, 2 * (nuint)Vector256<T>.Count) | 134Vector256.LoadUnsafe(ref searchSpace, 3 * (nuint)Vector256<T>.Count))) 139nuint i = 4 * (nuint)Vector256<T>.Count; 144nuint misalignedElements = Unsafe.OpportunisticMisalignment(ref searchSpace, (uint)Vector256<byte>.Count) / (nuint)sizeof(T); 146Debug.Assert((int)i > 3 * Vector256<T>.Count); 148nuint finalStart = (nuint)length - 4 * (nuint)Vector256<T>.Count; 150for (; i < finalStart; i += 4 * (nuint)Vector256<T>.Count) 156Vector256.LoadUnsafe(ref current, (nuint)Vector256<T>.Count) | 157Vector256.LoadUnsafe(ref current, 2 * (nuint)Vector256<T>.Count) | 158Vector256.LoadUnsafe(ref current, 3 * (nuint)Vector256<T>.Count))) 172Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<T>.Count) | 173Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, 2 * Vector256<T>.Count)) | 174Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count)));

95else if (Avx.IsSupported && length >= (uint)Vector256<TLeft>.Count) 101Debug.Assert(Vector256<TLeft>.Count == Vector256<TRight>.Count 102|| (typeof(TLoader) == typeof(WideningLoader) && Vector256<TLeft>.Count == Vector256<TRight>.Count * 2)); 103ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TLeft>.Count); 113currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, Vector256<TLeft>.Count); 114currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, Vector256<TLeft>.Count); 119if (length % (uint)Vector256<TLeft>.Count != 0) 121ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref left, length - (uint)Vector256<TLeft>.Count); 306else if (Avx.IsSupported && length >= (uint)Vector256<TRight>.Count) 309ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector256<TRight>.Count); 311ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TRight>.Count); 346currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector256<TRight>.Count); 347currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector256<TRight>.Count); 352if (length % (uint)Vector256<TRight>.Count != 0) 546Debug.Assert(Vector256<byte>.Count == Vector256<ushort>.Count * 2); 556Vector256<ushort> rightNext = Vector256.LoadUnsafe(ref utf16, (uint)Vector256<ushort>.Count);

180else if (Vector256.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector256<byte>.Count) 803else if (Vector256.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector256<ushort>.Count) 1381else if (Vector256.IsHardwareAccelerated && elementCount >= 2 * (uint)Vector256<byte>.Count) 2084else if (Vector256.IsHardwareAccelerated && (elementCount - currentOffset) >= (uint)Vector256<byte>.Count)

172while (Vector256.IsHardwareAccelerated && offset >= Vector256<nuint>.Count + 1) 174Vector256<nuint> current = Vector256.LoadUnsafe(ref start, (nuint)(offset - Vector256<nuint>.Count)) << shift; 175Vector256<nuint> carries = Vector256.LoadUnsafe(ref start, (nuint)(offset - (Vector256<nuint>.Count + 1))) >> back; 179Vector256.StoreUnsafe(newValue, ref start, (nuint)(offset - Vector256<nuint>.Count)); 180offset -= Vector256<nuint>.Count; 241while (Vector256.IsHardwareAccelerated && remaining.Length >= Vector256<nuint>.Count + 1) 249remaining = remaining.Slice(Vector256<nuint>.Count);

87while (Vector256.IsHardwareAccelerated && d.Length >= Vector256<nuint>.Count) 91d = d.Slice(Vector256<nuint>.Count);