diff --git a/src/MissingValues.Tests/Core/CalculatorTests.cs b/src/MissingValues.Tests/Core/CalculatorTests.cs
new file mode 100644
index 0000000..7920197
--- /dev/null
+++ b/src/MissingValues.Tests/Core/CalculatorTests.cs
@@ -0,0 +1,371 @@
+using MissingValues.Internals;
+using MissingValues.Tests.Data;
+using static MissingValues.Tests.Data.CalculatorDataSources;
+
+namespace MissingValues.Tests.Core;
+
+public class CalculatorTests
+{
+	[Test]
+	public async Task AddWithCarry_NoOverflow_ReturnsCorrectSumAndZeroCarry()
+	{
+		ulong a = 10;
+		ulong b = 20;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+
+		using var _ = Assert.Multiple();
+		
+		await Assert.That(result).IsEqualTo(30UL);
+		await Assert.That(carry).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task AddWithCarry_MaxValueAndOne_ReturnsZeroAndCarry()
+	{
+		ulong a = ulong.MaxValue;
+		ulong b = 1;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(0UL);
+		await Assert.That(carry).IsEqualTo(1UL);
+	}
+	[Test]
+	public async Task AddWithCarry_OverflowCase_ReturnsCorrectResultAndCarry()
+	{
+		ulong a = ulong.MaxValue - 1;
+		ulong b = 5;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(3UL);
+		await Assert.That(carry).IsEqualTo(1UL);
+	}
+	[Test]
+	public async Task AddWithCarry_AddZero_ReturnsSameValueAndZeroCarry()
+	{
+		ulong a = 123456789;
+		ulong b = 0;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(a);
+		await Assert.That(carry).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task AddWithCarry_BothZero_ReturnsZeroAndZeroCarry()
+	{
+		ulong a = 0;
+		ulong b = 0;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(0UL);
+		await Assert.That(carry).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task AddWithCarry_ExactMaxValueSum_ReturnsMaxValueAndZeroCarry()
+	{
+		ulong a = ulong.MaxValue / 2;
+		ulong b = ulong.MaxValue / 2;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(ulong.MaxValue - 1);
+		await Assert.That(carry).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task AddWithCarry_CarryOnlyTriggeredWhenOverflow()
+	{
+		ulong a = ulong.MaxValue;
+		ulong b = 0;
+
+		ulong result = Calculator.AddWithCarry(a, b, out ulong carry);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(result).IsEqualTo(ulong.MaxValue);
+		await Assert.That(carry).IsEqualTo(0UL);
+	}
+
+	[Test]
+	public async Task BigMulAdd_SimpleMultiplicationAndAddition()
+	{
+		ulong a = 2;
+		ulong b = 3;
+		ulong c = 5;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(0UL);
+		await Assert.That(lo).IsEqualTo(11UL);
+	}
+	[Test]
+	public async Task BigMulAdd_WithOverflowFromLowToHigh()
+	{
+		ulong a = ulong.MaxValue;
+		ulong b = 2;
+		ulong c = 1;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(1UL);
+		await Assert.That(lo).IsEqualTo(0xFFFFFFFFFFFFFFFFUL);
+	}
+	[Test]
+	public async Task BigMulAdd_MaxValues()
+	{
+		ulong a = ulong.MaxValue;
+		ulong b = ulong.MaxValue;
+		ulong c = ulong.MaxValue;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(0xFFFFFFFFFFFFFFFFUL);
+		await Assert.That(lo).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task BigMulAdd_NoCarryOrOverflow()
+	{
+		ulong a = 1000;
+		ulong b = 1000;
+		ulong c = 1;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(0UL);
+		await Assert.That(lo).IsEqualTo(1_000_001UL);
+	}
+	[Test]
+	public async Task BigMulAdd_CausesCarryFromAdditionOnly()
+	{
+		ulong a = ulong.MaxValue;
+		ulong b = 1;
+		ulong c = 1;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(1UL);
+		await Assert.That(lo).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task BigMulAdd_CausesNoCarryWithZeroInputs()
+	{
+		ulong a = 0;
+		ulong b = 0;
+		ulong c = 0;
+
+		var (hi, lo) = Calculator.BigMulAdd(a, b, c);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(hi).IsEqualTo(0UL);
+		await Assert.That(lo).IsEqualTo(0UL);
+	}
+
+	[Test]
+	public async Task DivRemByUInt32_BasicDivision()
+	{
+		ulong left = 100;
+		uint right = 7;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(14UL);
+		await Assert.That(remainder).IsEqualTo(2U);
+	}
+	[Test]
+	public async Task DivRemByUInt32_DivideByOne()
+	{
+		ulong left = 1234567890123456789;
+		uint right = 1;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(left);
+		await Assert.That(remainder).IsEqualTo(0U);
+	}
+	[Test]
+	public async Task DivRemByUInt32_DivideByMaxUInt32()
+	{
+		ulong left = (ulong)uint.MaxValue + 1;
+		uint right = uint.MaxValue;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(1UL);
+		await Assert.That(remainder).IsEqualTo(1U);
+	}
+	[Test]
+	public async Task DivRemByUInt32_ZeroDividend()
+	{
+		ulong left = 0;
+		uint right = uint.MaxValue;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(0UL);
+		await Assert.That(remainder).IsEqualTo(0U);
+	}
+	[Test]
+	public async Task DivRemByUInt32_ExactDivision()
+	{
+		ulong left = 400;
+		uint right = 20;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(20UL);
+		await Assert.That(remainder).IsEqualTo(0U);
+	}
+	[Test]
+	public async Task DivRemByUInt32_MaxValues()
+	{
+		ulong left = ulong.MaxValue;
+		uint right = uint.MaxValue;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt32(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(ulong.MaxValue / uint.MaxValue);
+		await Assert.That(remainder).IsEqualTo((uint)(ulong.MaxValue % uint.MaxValue));
+	}
+	[Test]
+	public async Task DivRemByUInt32_DivideByZero_Throws()
+	{
+		ulong left = 100;
+		uint right = 0;
+
+		await Assert.That(() => Calculator.DivRemByUInt32(left, right)).Throws<DivideByZeroException>();
+	}
+
+	[Test]
+	public async Task DivRemByUInt64_BasicDivision()
+	{
+		UInt128 left = new UInt128(0, 1000);
+		ulong right = 30;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(new UInt128(0, 33));
+		await Assert.That(remainder).IsEqualTo(10UL);
+	}
+	[Test]
+	public async Task DivRemByUInt64_ZeroDividend()
+	{
+		UInt128 left = new UInt128(0, 0);
+		ulong right = 12345;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(UInt128.Zero);
+		await Assert.That(remainder).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task DivRemByUInt64_DivideByOne()
+	{
+		UInt128 left = new UInt128(123456789, 9876543210);
+		ulong right = 1;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(new UInt128(123456789, 9876543210));
+		await Assert.That(remainder).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task DivRemByUInt64_ExactDivision()
+	{
+		UInt128 left = new UInt128(0, 1000);
+		ulong right = 1000;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(new UInt128(0, 1));
+		await Assert.That(remainder).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task DivRemByUInt64_UpperBitsUsed()
+	{
+		UInt128 left = new UInt128(1, 0);
+		ulong right = 2;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(new UInt128(0, 1UL << 63));
+		await Assert.That(remainder).IsEqualTo(0UL);
+	}
+	[Test]
+	public async Task DivRemByUInt64_MaxValues()
+	{
+		UInt128 left = UInt128.MaxValue;
+		ulong right = ulong.MaxValue;
+
+		var (quotient, remainder) = Calculator.DivRemByUInt64(left, right);
+		
+		using var _ = Assert.Multiple();
+
+		await Assert.That(quotient).IsEqualTo(UInt128.MaxValue / ulong.MaxValue);
+		await Assert.That(remainder).IsEqualTo((ulong)(UInt128.MaxValue % ulong.MaxValue));
+	}
+	[Test]
+	public async Task DivRemByUInt64_DivideByZero_Throws()
+	{
+		UInt128 left = new UInt128(1, 0);
+		ulong right = 0;
+
+		await Assert.That(() => Calculator.DivRemByUInt64(left, right)).Throws<DivideByZeroException>();
+	}
+
+	[Test]
+	[MethodDataSource(typeof(CalculatorDataSources), nameof(Log10TestData))]
+	public async Task Log10_DataDriven(UInt512 value, int expected)
+	{
+		await Assert.That(BitHelper.Log10(in value)).IsEqualTo(expected);
+	}
+	[Test]
+	public async Task Log10_NegativeInput_Throws()
+	{
+		await Assert.That(() => BitHelper.Log10(in Int512.NegativeOne)).Throws<ArgumentException>();
+	}
+}
diff --git a/src/MissingValues.Tests/Core/Int256Test.GenericMath.cs b/src/MissingValues.Tests/Core/Int256Test.GenericMath.cs
deleted file mode 100644
index a9d8505..0000000
--- a/src/MissingValues.Tests/Core/Int256Test.GenericMath.cs
+++ /dev/null
@@ -1,1278 +0,0 @@
-using FluentAssertions;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-using Int = MissingValues.Int256;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class Int256Test
-	{
-		#region Readonly Variables
-		private const double Int256MaxValueAsDouble = 57896044618658097711785492504343953926634992332820282019728792003956564819967.0;
-		private const double Int256MinValueAsDouble = -57896044618658097711785492504343953926634992332820282019728792003956564819968.0d;
-
-		private static readonly Int SByteMaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_007F));
-		private static readonly Int SByteMinValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
-
-		private static readonly Int ByteMaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_00FF));
-
-		private static readonly Int Int16MaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF));
-		private static readonly Int Int16MinValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
-
-		private static readonly Int UInt16MaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF));
-
-		private static readonly Int Int32MaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF));
-		private static readonly Int Int32MinValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
-
-		private static readonly Int UInt32MaxValue = new(new(0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF));
-
-		private static readonly Int Int64MaxValue = new(new(0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF));
-		private static readonly Int Int64MinValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
-
-		private static readonly Int UInt64MaxValue = new(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF));
-
-		private static readonly Int Int128MaxValue = new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-		private static readonly Int Int128MinValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
-
-		private static readonly Int UInt128MaxValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-
-		private static readonly Int NegativeOne = Int.NegativeOne;
-		private static readonly Int NegativeTwo = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		private static readonly Int Zero = Int.Zero;
-		private static readonly Int One = Int.One;
-		private static readonly Int Two = new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0002));
-		private static readonly Int MaxValue = Int.MaxValue;
-		private static readonly Int MaxValueMinusOne = new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		private static readonly Int MinValue = Int.MinValue;
-		private static readonly Int MinValuePlusOne = new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
-		#endregion
-
-		#region Generic Math Operators
-		[Fact]
-		public static void op_AdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(Two, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(One, 1));
-			Assert.Equal(MinValue, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(Zero, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(NegativeOne, 1));
-		}
-		[Fact]
-		public static void op_CheckedAdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(Int.One, 1));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(Zero, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(NegativeOne, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(MaxValue, 1));
-		}
-		[Fact]
-		public static void op_IncrementTest()
-		{
-			MathOperatorsHelper.IncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.IncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.IncrementOperation(MinValue).Should().Be(MinValuePlusOne);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-			MathOperatorsHelper.IncrementOperation(MaxValue).Should().Be(MinValue);
-		}
-		[Fact]
-		public static void op_CheckedIncrementTest()
-		{
-			MathOperatorsHelper.CheckedIncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.CheckedIncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.CheckedIncrementOperation(MinValue).Should().Be(MinValuePlusOne);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedIncrementOperation(MaxValue));
-		}
-		[Fact]
-		public static void op_SubtractionTest()
-		{
-			Assert.Equal(NegativeOne, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(One, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(Two, 1));
-			Assert.Equal(MaxValue, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(NegativeOne, 1));
-		}
-		[Fact]
-		public static void op_CheckedSubtractionTest()
-		{
-			Assert.Equal(NegativeOne, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(One, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(Two, 1));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(NegativeOne, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(MinValue, 1));
-		}
-		[Fact]
-		public static void op_DecrementTest()
-		{
-			MathOperatorsHelper.DecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.DecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.DecrementOperation(MinValuePlusOne).Should().Be(MinValue);
-			MathOperatorsHelper.DecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.DecrementOperation(MinValue).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_CheckedDecrementTest()
-		{
-			MathOperatorsHelper.CheckedDecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.CheckedDecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.CheckedDecrementOperation(MinValuePlusOne).Should().Be(MinValue);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDecrementOperation(MinValue));
-		}
-		[Fact]
-		public static void op_MultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(Two, One));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(Two, NegativeOne));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(MaxValue, NegativeOne));
-			Assert.Equal(MinValue, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_CheckedMultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(Two, One));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(Two, NegativeOne));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(MaxValue, NegativeOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_DivisionTest()
-		{
-			Assert.Equal(new Int(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, Two));
-			Assert.Equal(new Int(new(0xC000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValueMinusOne, NegativeTwo));
-			Assert.Equal(One, MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, MaxValue));
-			Assert.Equal(NegativeOne, MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, MinValuePlusOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_CheckedDivisionTest()
-		{
-			Assert.Equal(new Int(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, Two));
-			Assert.Equal(new Int(new(0xC000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValueMinusOne, NegativeTwo));
-			Assert.Equal(One, MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, MaxValue));
-			Assert.Equal(NegativeOne, MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, MinValuePlusOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_ModulusTest()
-		{
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(Two, Two).Should().Be(Zero);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(One, Two).Should().NotBe(Zero);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(MaxValue, new(10U)).Should().Be(7);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(MinValue, new(10U)).Should().Be(-8);
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.ModulusOperation<Int, Int, Int>(One, Zero));
-		}
-
-		[Fact]
-		public static void op_BitwiseAndTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(Zero, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(One, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(MaxValue, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(MinValue, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(NegativeOne, 1U).Should().Be(One);
-		}
-		[Fact]
-		public static void op_BitwiseOrTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(One, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(MaxValue, 1U)
-				.Should().Be(MaxValue);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(MinValue, 1U)
-				.Should().Be(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)));
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(NegativeOne, 1U)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-		}
-		[Fact]
-		public static void op_ExclusiveOrTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(One, 1U)
-				.Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(MaxValue, 1U)
-				.Should().Be(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)));
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(MinValue, 1U)
-				.Should().Be(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)));
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(NegativeOne, 1U)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)));
-		}
-		[Fact]
-		public static void op_OnesComplementTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(Zero)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(One)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(MaxValue)
-				.Should().Be(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(MinValue)
-				.Should().Be(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(NegativeOne)
-				.Should().Be(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-		}
-
-		[Fact]
-		public static void op_LeftShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(One, 1)
-				.Should().Be(Two);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(MaxValue, 1)
-				.Should().Be(NegativeTwo);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(MinValue, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(NegativeOne, 1)
-				.Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void op_RightShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(MaxValue, 1)
-				.Should().Be(new(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(MinValue, 1)
-				.Should().Be(new(new(0xC000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(NegativeOne, 1)
-				.Should().Be(NegativeOne);
-
-			var actual = new Int(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 1)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 2)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 3)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
-		}
-		[Fact]
-		public static void op_UnsignedRightShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(MaxValue, 1)
-				.Should().Be(new(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(MinValue, 1)
-				.Should().Be(new(new(0x4000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(NegativeOne, 1)
-				.Should().Be(MaxValue);
-		}
-
-		[Fact]
-		public static void op_EqualityTest()
-		{
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(Zero, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(One, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(MaxValue, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(MinValue, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_InequalityTest()
-		{
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(Zero, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(One, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(MaxValue, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(MinValue, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void op_GreaterThanTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(MaxValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(MinValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_GreaterThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(MaxValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(MinValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_LessThanTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(MaxValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(MinValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-		[Fact]
-		public static void op_LessThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(MaxValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(MinValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-		#endregion
-
-		#region Identities
-		[Fact]
-		public static void AdditiveIdentityTest()
-		{
-			Assert.Equal(Zero, MathConstantsHelper.AdditiveIdentityHelper<Int, Int>());
-		}
-
-		[Fact]
-		public static void MultiplicativeIdentityTest()
-		{
-			Assert.Equal(One, MathConstantsHelper.MultiplicativeIdentityHelper<Int, Int>());
-		} 
-		#endregion
-
-		#region IBinaryInteger
-		[Fact]
-		public static void DivRemTest()
-		{
-			Assert.Equal((Zero, Zero), BinaryIntegerHelper<Int>.DivRem(Zero, Two));
-			Assert.Equal((Zero, One), BinaryIntegerHelper<Int>.DivRem(One, Two));
-			Assert.Equal((new Int(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), One), BinaryIntegerHelper<Int>.DivRem(MaxValue, 2));
-			Assert.Equal((new Int(new(0xC000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), Zero), BinaryIntegerHelper<Int>.DivRem(MinValue, 2));
-			Assert.Equal((Zero, NegativeOne), BinaryIntegerHelper<Int>.DivRem(NegativeOne, 2));
-		}
-
-		[Fact]
-		public static void LeadingZeroCountTest()
-		{
-			Assert.Equal(256, BinaryIntegerHelper<Int>.LeadingZeroCount(Zero));
-			Assert.Equal(255, BinaryIntegerHelper<Int>.LeadingZeroCount(One));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.LeadingZeroCount(MaxValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.LeadingZeroCount(MinValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.LeadingZeroCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void PopCountTest()
-		{
-			Assert.Equal(0, BinaryIntegerHelper<Int>.PopCount(Zero));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.PopCount(One));
-			Assert.Equal(255, BinaryIntegerHelper<Int>.PopCount(MaxValue));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.PopCount(MinValue));
-			Assert.Equal(256, BinaryIntegerHelper<Int>.PopCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void RotateLeftTest()
-		{
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<Int>.RotateLeft(Zero, 1));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0002)), BinaryIntegerHelper<Int>.RotateLeft(One, 1));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)), BinaryIntegerHelper<Int>.RotateLeft(MaxValue, 1));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), BinaryIntegerHelper<Int>.RotateLeft(MinValue, 1));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), BinaryIntegerHelper<Int>.RotateLeft(NegativeOne, 1));
-		}
-
-		[Fact]
-		public static void RotateRightTest()
-		{
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<Int>.RotateRight(Zero, 1));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<Int>.RotateRight(One, 1));
-			Assert.Equal(new(new(0xBFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), BinaryIntegerHelper<Int>.RotateRight(MaxValue, 1));
-			Assert.Equal(new(new(0x4000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<Int>.RotateRight(MinValue, 1));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), BinaryIntegerHelper<Int>.RotateRight(NegativeOne, 1));
-		}
-
-		[Fact]
-		public static void TrailingZeroCountTest()
-		{
-			Assert.Equal(256, BinaryIntegerHelper<Int>.TrailingZeroCount(Zero));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(One));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(MaxValue));
-			Assert.Equal(255, BinaryIntegerHelper<Int>.TrailingZeroCount(MinValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void TryReadBigEndianInt128Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new Int128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-		}
-
-		[Fact]
-		public static void TryReadBigEndianUInt128Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt128Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt192Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0100_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-		
-		[Fact]
-		public static void TryReadLittleEndianInt256Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt128Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt192Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0100_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x8000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt256Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-		}
-
-		[Fact]
-		public static void GetByteCountTest()
-		{
-			Assert.Equal(32, BinaryIntegerHelper<Int>.GetByteCount(Zero));
-			Assert.Equal(32, BinaryIntegerHelper<Int>.GetByteCount(One));
-			Assert.Equal(32, BinaryIntegerHelper<Int>.GetByteCount(MaxValue));
-			Assert.Equal(32, BinaryIntegerHelper<Int>.GetByteCount(MinValue));
-			Assert.Equal(32, BinaryIntegerHelper<Int>.GetByteCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void GetShortestBitLengthTest()
-		{
-			Assert.Equal(0x00, BinaryIntegerHelper<Int>.GetShortestBitLength(Zero));
-			Assert.Equal(0x01, BinaryIntegerHelper<Int>.GetShortestBitLength(One));
-			Assert.Equal(0xFF, BinaryIntegerHelper<Int>.GetShortestBitLength(MaxValue));
-			Assert.Equal(0x100, BinaryIntegerHelper<Int>.GetShortestBitLength(MinValue));
-			Assert.Equal(0x01, BinaryIntegerHelper<Int>.GetShortestBitLength(NegativeOne));
-		}
-
-		[Fact]
-		public static void TryWriteBigEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[32];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(One, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(MinValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(NegativeOne, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<Int>.TryWriteBigEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-
-		[Fact]
-		public static void TryWriteLittleEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[32];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(One, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(MinValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(NegativeOne, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<Int>.TryWriteLittleEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-		#endregion
-
-		#region IBinaryNumber
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			Assert.Equal(BinaryNumberHelper<Int>.AllBitsSet, ~Zero);
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x100)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1_0000)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1_0000_0000)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(new(0x1, 0x0000_0000_0000_0000))));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000))));
-		}
-		[Fact]
-		public static void Log2Test()
-		{
-			Assert.Equal(8, BinaryNumberHelper<Int>.Log2(new(0x100)));
-			Assert.Equal(16, BinaryNumberHelper<Int>.Log2(new(0x1_0000)));
-			Assert.Equal(32, BinaryNumberHelper<Int>.Log2(new(0x1_0000_0000)));
-			Assert.Equal(64, BinaryNumberHelper<Int>.Log2(new(new(0x1, 0x0000_0000_0000_0000))));
-			Assert.Equal(128, BinaryNumberHelper<Int>.Log2(new(0x1, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000))));
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<Int>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			MinValue.Should().Be(MathConstantsHelper.MinValue<Int>());
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<Int>.Clamp(MaxValueMinusOne, Int128MaxValue, MaxValue).Should().Be(MaxValueMinusOne);
-			NumberHelper<Int>.Clamp(MinValue, 0, MaxValue).Should().Be(0);
-			NumberHelper<Int>.Clamp(MaxValue, MinValue, 0).Should().Be(0);
-
-			Assert.Throws<ArgumentException>(() => NumberHelper<Int>.Clamp(MinValue, MaxValue, 0));
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<Int>.CopySign(MaxValue, NegativeOne).Should().Be(MinValuePlusOne);
-			NumberHelper<Int>.CopySign(MaxValue, One).Should().Be(MaxValue);
-			NumberHelper<Int>.CopySign(NegativeTwo, One).Should().Be(Two);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<Int>.Max(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberHelper<Int>.Max(One, NegativeTwo).Should().Be(One);
-			NumberHelper<Int>.Max(Two, NegativeOne).Should().Be(Two);
-			NumberHelper<Int>.Max(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<Int>.MaxNumber(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberHelper<Int>.MaxNumber(One, NegativeTwo).Should().Be(One);
-			NumberHelper<Int>.MaxNumber(Two, NegativeOne).Should().Be(Two);
-			NumberHelper<Int>.MaxNumber(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<Int>.Min(MaxValue, MinValue).Should().Be(MinValue);
-			NumberHelper<Int>.Min(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberHelper<Int>.Min(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberHelper<Int>.Min(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<Int>.MinNumber(MaxValue, MinValue).Should().Be(MinValue);
-			NumberHelper<Int>.MinNumber(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberHelper<Int>.MinNumber(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberHelper<Int>.MinNumber(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<Int>.Sign(MinValue).Should().Be(-1);
-			NumberHelper<Int>.Sign(MaxValue).Should().Be(1);
-			NumberHelper<Int>.Sign(Int.Zero).Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<Int>.Abs(MinValuePlusOne).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.Abs(NegativeTwo).Should().Be(Two);
-			NumberBaseHelper<Int>.Abs(NegativeOne).Should().Be(One);
-			NumberBaseHelper<Int>.Abs(One).Should().Be(One);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Abs(MinValue));
-		}
-		[Fact]
-		public static void CreateCheckedToInt256Test()
-		{
-			NumberBaseHelper<Int>.CreateChecked(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateChecked(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateChecked(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(Int256MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<Int>.CreateChecked(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateChecked(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateChecked(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateChecked(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateChecked(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>
-				.CreateChecked(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateChecked(Int256MinValueAsDouble).Should().Be(MinValue);
-		}
-		[Fact]
-		public static void CreateSaturatingToInt256Test()
-		{
-			NumberBaseHelper<Int>.CreateSaturating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateSaturating(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int256MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<Int>.CreateSaturating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateSaturating(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>
-				.CreateSaturating(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int256MinValueAsDouble).Should().Be(MinValue);
-		}
-		[Fact]
-		public static void CreateTruncatingToInt256Test()
-		{
-			NumberBaseHelper<Int>.CreateTruncating(sbyte.MaxValue).Should().Be(SByteMaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateTruncating(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int256MaxValueAsDouble).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(UInt256.MaxValue).Should().Be(NegativeOne);
-
-			NumberBaseHelper<Int>.CreateTruncating(sbyte.MinValue).Should().Be(SByteMinValue);
-			NumberBaseHelper<Int>.CreateTruncating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateTruncating(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateTruncating(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateTruncating(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateTruncating(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(UInt128.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>
-				.CreateTruncating(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int256MinValueAsDouble).Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(UInt256.MinValue).Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void CreateCheckedFromInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateChecked(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateChecked(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateChecked(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateChecked(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateChecked(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"));
-			NumberBaseHelper<double>.CreateChecked(MaxValue).Should().Be(Int256MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateChecked(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateChecked(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateChecked(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateChecked(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateChecked(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<double>.CreateChecked(MinValue).Should().Be(Int256MinValueAsDouble);
-		}
-		[Fact]
-		public static void CreateSaturatingFromInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateSaturating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateSaturating(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateSaturating(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateSaturating(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateSaturating(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"));
-			NumberBaseHelper<double>.CreateSaturating(MaxValue).Should().Be(Int256MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateSaturating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateSaturating(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateSaturating(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateSaturating(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateSaturating(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<double>.CreateSaturating(MinValue).Should().Be(Int256MinValueAsDouble);
-		}
-		[Fact]
-		public static void CreateTruncatingFromInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateTruncating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateTruncating(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateTruncating(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateTruncating(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateTruncating(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"57896044618658097711785492504343953926634992332820282019728792003956564819967"));
-			NumberBaseHelper<double>.CreateTruncating(MaxValue).Should().Be(Int256MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateTruncating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateTruncating(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateTruncating(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateTruncating(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateTruncating(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<double>.CreateTruncating(MinValue).Should().Be(Int256MinValueAsDouble);
-		}
-
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<Int>.IsCanonical(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<Int>.IsComplexNumber(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsEvenInteger(Two).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<Int>.IsFinite(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<Int>.IsImaginaryNumber(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsInfinity(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsInteger(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<Int>.IsNaN(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<Int>.IsNegative(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsNegative(NegativeOne).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsNegativeInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<Int>.IsNormal(Zero).Should().BeFalse();
-			NumberBaseHelper<Int>.IsNormal(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<Int>.IsOddInteger(Two).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<Int>.IsPositive(One).Should().BeTrue();
-			NumberBaseHelper<Int>.IsPositive(NegativeOne).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsPositiveInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<Int>.IsRealNumber(default).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<Int>.IsSubnormal(default).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<Int>.IsZero(default).Should().BeTrue();
-			NumberBaseHelper<Int>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<Int>.IsZero(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsZero(NegativeOne).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<Int>.MaxMagnitude(MaxValue, MinValue).Should().Be(MinValue);
-			NumberBaseHelper<Int>.MaxMagnitude(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberBaseHelper<Int>.MaxMagnitude(Two, NegativeOne).Should().Be(Two);
-			NumberBaseHelper<Int>.MaxMagnitude(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(MaxValue, MinValue).Should().Be(MinValue);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(Two, NegativeOne).Should().Be(Two);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<Int>.MinMagnitude(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.MinMagnitude(One, NegativeTwo).Should().Be(One);
-			NumberBaseHelper<Int>.MinMagnitude(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberBaseHelper<Int>.MinMagnitude(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Int>.MinMagnitudeNumber(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(One, NegativeTwo).Should().Be(One);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-
-		[Fact]
-		public void ParseTest()
-		{
-			NumberBaseHelper<Int>.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.Parse("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-			NumberBaseHelper<Int>.Parse("8000000000000000000000000000000000000000000000000000000000000000", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819969", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseTest()
-		{
-			NumberBaseHelper<Int>.TryParse("57896044618658097711785492504343953926634992332820282019728792003956564819967", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out Int parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.TryParse("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.TryParse("-57896044618658097711785492504343953926634992332820282019728792003956564819968", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-			NumberBaseHelper<Int>.TryParse("8000000000000000000000000000000000000000000000000000000000000000", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-
-			NumberBaseHelper<Int>.TryParse("57896044618658097711785492504343953926634992332820282019728792003956564819968", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-			NumberBaseHelper<Int>.TryParse("-57896044618658097711785492504343953926634992332820282019728792003956564819969", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-
-		[Fact]
-		public void ParseUtf8Test()
-		{
-			NumberBaseHelper<Int>.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.Parse("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-			NumberBaseHelper<Int>.Parse("8000000000000000000000000000000000000000000000000000000000000000"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819969"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseUtf8Test()
-		{
-			NumberBaseHelper<Int>.TryParse("57896044618658097711785492504343953926634992332820282019728792003956564819967"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out Int parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.TryParse("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MaxValue)
-				.And.BeRankedEquallyTo(Int256MaxValue);
-			NumberBaseHelper<Int>.TryParse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-			NumberBaseHelper<Int>.TryParse("8000000000000000000000000000000000000000000000000000000000000000"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int256MinValue)
-				.And.BeRankedEquallyTo(Int256MinValue);
-
-			NumberBaseHelper<Int>.TryParse("57896044618658097711785492504343953926634992332820282019728792003956564819968"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-			NumberBaseHelper<Int>.TryParse("-57896044618658097711785492504343953926634992332820282019728792003956564819969"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-		#endregion
-
-		#region ISignedNumber
-		[Fact]
-		public static void NegativeOneTest()
-		{
-			MathConstantsHelper.NegativeOne<Int>().Should().Be(NegativeOne);	
-		}
-		#endregion
-
-		#region IPowerFunctions
-		[Fact]
-		public void PowTest()
-		{
-			GenericFloatingPointFunctions.Pow(Zero, int.MaxValue).Should().Be(Zero);
-			GenericFloatingPointFunctions.Pow(One, int.MaxValue).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, Zero).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, One).Should().Be(MaxValue);
-			GenericFloatingPointFunctions.Pow(Two, Two).Should().Be(4);
-			GenericFloatingPointFunctions.Pow(Two, 4).Should().Be(16);
-			GenericFloatingPointFunctions.Pow(16, Two).Should().Be(256);
-			GenericFloatingPointFunctions.Pow(Two, 254)
-				.Should().Be(new Int(0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-
-			Assert.Throws<ArgumentOutOfRangeException>(() => GenericFloatingPointFunctions.Pow(Two, NegativeOne));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two, 255));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two + Two, 254));
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/Int256Test.cs b/src/MissingValues.Tests/Core/Int256Test.cs
deleted file mode 100644
index 69edd7d..0000000
--- a/src/MissingValues.Tests/Core/Int256Test.cs
+++ /dev/null
@@ -1,251 +0,0 @@
-using FluentAssertions;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-using Xunit;
-
-using Int = MissingValues.Int256;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class Int256Test
-	{
-		private static readonly Int Int256MaxValue = new(
-			new UInt128(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF),
-			new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)
-			);
-		private static readonly Int Int256MinValue = new(
-			new UInt128(0x8000_0000_0000_0000, 0x0000_0000_0000_0000),
-			new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)
-			);
-
-		[Fact]
-		public void Ctor_Empty()
-		{
-			var i = new Int();
-			Assert.Equal(0, i);
-		}
-
-		[Fact]
-		public void Ctor_Value()
-		{
-			var i = new Int(UInt128.Zero, new(0, 7));
-			Assert.Equal(7, i);
-		}
-
-		[Fact]
-		public void Cast_ToByte()
-		{
-			byte.MinValue.Should().Be((byte)Zero);
-			byte.MaxValue.Should().Be((byte)ByteMaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt16()
-		{
-			short.MinValue.Should().Be((short)Int16MinValue);
-			short.MaxValue.Should().Be((short)Int16MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt32()
-		{
-			int.MinValue.Should().Be((int)Int32MinValue);
-			int.MaxValue.Should().Be((int)Int32MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt64()
-		{
-			long.MinValue.Should().Be((long)Int64MinValue);
-			long.MaxValue.Should().Be((long)Int64MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt128()
-		{
-			Int128.MinValue.Should().Be((Int128)Int128MinValue);
-			Int128.MaxValue.Should().Be((Int128)Int128MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.One.Should().Be((BigInteger)One);
-			BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967")
-				.Should().Be((BigInteger)MaxValue);
-			BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968")
-				.Should().Be((BigInteger)MinValue);
-		}
-
-		[Fact]
-		public void Cast_ToDouble()
-		{
-			const double max = 57896044618658097711785492504343953926634992332820282019728792003956564819967.0;
-			const double min = -57896044618658097711785492504343953926634992332820282019728792003956564819968.0;
-
-			max.Should().Be((double)Int256MaxValue);
-			min.Should().Be((double)Int256MinValue);
-		}
-
-		[Fact]
-		public void ToDecStringTest()
-		{
-			Zero.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("0");
-			One.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			MaxValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("57896044618658097711785492504343953926634992332820282019728792003956564819967");
-			MinValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("-57896044618658097711785492504343953926634992332820282019728792003956564819968");
-		}
-		[Fact]
-		public void ToHexStringTest()
-		{
-			One.ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((Int)sbyte.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7F");
-			((Int)short.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFF");
-			((Int)int.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFF");
-			((Int)long.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFFFFFFFFFF");
-			((Int)Int128.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-
-			Zero.ToString("X64", CultureInfo.CurrentCulture)
-				.Should().Be("0000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("x64", CultureInfo.CurrentCulture)
-				.Should().Be("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-			MaxValue.ToString("X64", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-			MinValue.ToString("X64", CultureInfo.CurrentCulture)
-				.Should().Be("8000000000000000000000000000000000000000000000000000000000000000");
-		}
-		[Fact]
-		public void ToBinStringTest()
-		{
-			One.ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((Int)sbyte.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111");
-			((Int)short.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("111111111111111");
-			((Int)int.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111");
-			((Int)long.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("111111111111111111111111111111111111111111111111111111111111111");
-			((Int)Int128.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-
-			Zero.ToString("B256", CultureInfo.CurrentCulture)
-				.Should().Be("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("B256", CultureInfo.CurrentCulture)
-				.Should().Be("0111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-			MinValue.ToString("B256", CultureInfo.CurrentCulture)
-				.Should().Be("1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-		}
-
-		[Fact]
-		public void ToDecFormatStringTest()
-		{
-			MaxValue.ToString().Should().Be($"{MaxValue:D}");
-			MinValue.ToString().Should().Be($"{MinValue:D}");
-		}
-		[Fact]
-		public void ToHexFormatStringTest()
-		{
-			MaxValue.ToString("X64", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:X64}");
-			MinValue.ToString("X64", CultureInfo.CurrentCulture).Should().Be($"{MinValue:X64}");
-		}
-		[Fact]
-		public void ToBinFormatStringTest()
-		{
-			MaxValue.ToString("B256", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:B256}");
-			MinValue.ToString("B256", CultureInfo.CurrentCulture).Should().Be($"{MinValue:B256}");
-		}
-
-		[Fact]
-		public void ToDecFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString()!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString()!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToHexFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("X64", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:X64}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString("X64", CultureInfo.CurrentCulture)!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:X64}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToBinFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("B256", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:B256}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString("B256", CultureInfo.CurrentCulture)!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:B256}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new object[] { MaxValue, MinValue, One, NegativeOne })
-				.Should().Be("[57896044618658097711785492504343953926634992332820282019728792003956564819967,-57896044618658097711785492504343953926634992332820282019728792003956564819968,1,-1]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			JsonSerializer.Deserialize<Int>("57896044618658097711785492504343953926634992332820282019728792003956564819967")
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<Int>("57896044618658097711785492504343953926634992332820282019728792003956564819967"u8)
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<Int>("-57896044618658097711785492504343953926634992332820282019728792003956564819968")
-				.Should().Be(MinValue);
-			JsonSerializer.Deserialize<Int>("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8)
-				.Should().Be(MinValue);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/Int512Test.GenericMath.cs b/src/MissingValues.Tests/Core/Int512Test.GenericMath.cs
deleted file mode 100644
index fdb887f..0000000
--- a/src/MissingValues.Tests/Core/Int512Test.GenericMath.cs
+++ /dev/null
@@ -1,1191 +0,0 @@
-using FluentAssertions;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-using Int = MissingValues.Int512;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class Int512Test
-	{
-		#region Readonly Variables
-		private const double Int512MaxValueAsDouble = 6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047.0;
-		private const double Int512MinValueAsDouble = -6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.0d;
-
-		private static readonly Int ByteMaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
-
-		private static readonly Int Int16MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF);
-		private static readonly Int Int16MinValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000);
-
-		private static readonly Int Int32MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF);
-		private static readonly Int Int32MinValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000);
-
-		private static readonly Int Int64MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF);
-		private static readonly Int Int64MinValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000);
-
-		private static readonly Int Int128MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-		private static readonly Int Int128MinValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		private static readonly Int Int256MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF
-			);
-		private static readonly Int Int256MinValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000
-			);
-
-		private static readonly Int NegativeOne = Int.NegativeOne;
-		private static readonly Int NegativeTwo = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
-		private static readonly Int Zero = Int.Zero;
-		private static readonly Int One = Int.One;
-		private static readonly Int Two = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
-		private static readonly Int MaxValue = Int.MaxValue;
-		private static readonly Int MaxValueMinusOne = new(
-			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
-		private static readonly Int MinValue = Int.MinValue;
-		private static readonly Int MinValuePlusOne = new(
-			0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-		#endregion
-
-		#region Generic Math Operators
-		[Fact]
-		public static void op_AdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(Two, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(One, 1));
-			Assert.Equal(MinValue, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(Zero, MathOperatorsHelper.AdditionOperation<Int, Int, Int>(NegativeOne, 1));
-		}
-		[Fact]
-		public static void op_CheckedAdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(Int.One, 1));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(Zero, MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(NegativeOne, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedAdditionOperation<Int, Int, Int>(MaxValue, 1));
-		}
-		[Fact]
-		public static void op_IncrementTest()
-		{
-			MathOperatorsHelper.IncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.IncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.IncrementOperation(MinValue).Should().Be(MinValuePlusOne);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-			MathOperatorsHelper.IncrementOperation(MaxValue).Should().Be(MinValue);
-		}
-		[Fact]
-		public static void op_CheckedIncrementTest()
-		{
-			MathOperatorsHelper.CheckedIncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.CheckedIncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.CheckedIncrementOperation(MinValue).Should().Be(MinValuePlusOne);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedIncrementOperation(MaxValue));
-		}
-		[Fact]
-		public static void op_SubtractionTest()
-		{
-			Assert.Equal(NegativeOne, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(One, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(Two, 1));
-			Assert.Equal(MaxValue, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(MinValue, 1));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.SubtractionOperation<Int, Int, Int>(NegativeOne, 1));
-		}
-		[Fact]
-		public static void op_CheckedSubtractionTest()
-		{
-			Assert.Equal(NegativeOne, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(Zero, 1));
-			Assert.Equal(One, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(Two, 1));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(MaxValue, 1));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(NegativeOne, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedSubtractionOperation<Int, Int, Int>(MinValue, 1));
-		}
-		[Fact]
-		public static void op_DecrementTest()
-		{
-			MathOperatorsHelper.DecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.DecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.DecrementOperation(MinValuePlusOne).Should().Be(MinValue);
-			MathOperatorsHelper.DecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.DecrementOperation(MinValue).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_CheckedDecrementTest()
-		{
-			MathOperatorsHelper.CheckedDecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.CheckedDecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.CheckedDecrementOperation(MinValuePlusOne).Should().Be(MinValue);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDecrementOperation(MinValue));
-		}
-		[Fact]
-		public static void op_MultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(Two, One));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(Two, NegativeOne));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(MaxValue, NegativeOne));
-			Assert.Equal(MinValue, MathOperatorsHelper.MultiplicationOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_CheckedMultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(Two, One));
-			Assert.Equal(NegativeTwo, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(Two, NegativeOne));
-			Assert.Equal(MinValuePlusOne, MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(MaxValue, NegativeOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedMultiplicationOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_DivisionTest()
-		{
-			Assert.Equal(new Int(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, Two));
-			Assert.Equal(new Int(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValueMinusOne, NegativeTwo));
-			Assert.Equal(One, MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, MaxValue));
-			Assert.Equal(NegativeOne, MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MaxValue, MinValuePlusOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.DivisionOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_CheckedDivisionTest()
-		{
-			Assert.Equal(new Int(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, Two));
-			Assert.Equal(new Int(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValueMinusOne, NegativeTwo));
-			Assert.Equal(One, MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, MaxValue));
-			Assert.Equal(NegativeOne, MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MaxValue, MinValuePlusOne));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDivisionOperation<Int, Int, Int>(MinValue, NegativeOne));
-		}
-		[Fact]
-		public static void op_ModulusTest()
-		{
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(Two, Two).Should().Be(Zero);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(One, Two).Should().NotBe(Zero);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(MaxValue, new(10U)).Should().Be(7);
-			MathOperatorsHelper.ModulusOperation<Int, Int, Int>(MinValue, new(10U)).Should().Be(-8);
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.ModulusOperation<Int, Int, Int>(One, Zero));
-		}
-
-		[Fact]
-		public static void op_BitwiseAndTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(Zero, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(One, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(MaxValue, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(MinValue, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseAndOperation(NegativeOne, 1U).Should().Be(One);
-		}
-		[Fact]
-		public static void op_BitwiseOrTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(One, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(MaxValue, 1U)
-				.Should().Be(MaxValue);
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(MinValue, 1U)
-				.Should().Be(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
-			BitwiseOperatorsHelper<Int, Int, Int>.BitwiseOrOperation(NegativeOne, 1U)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-		}
-		[Fact]
-		public static void op_ExclusiveOrTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(One, 1U)
-				.Should().Be(Zero);
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(MaxValue, 1U)
-				.Should().Be(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(MinValue, 1U)
-				.Should().Be(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
-			BitwiseOperatorsHelper<Int, Int, Int>.ExclusiveOrOperation(NegativeOne, 1U)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		}
-		[Fact]
-		public static void op_OnesComplementTest()
-		{
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(Zero)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(One)
-				.Should().Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(MaxValue)
-				.Should().Be(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(MinValue)
-				.Should().Be(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			BitwiseOperatorsHelper<Int, Int, Int>.OnesComplementOperation(NegativeOne)
-				.Should().Be(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-		}
-
-		[Fact]
-		public static void op_LeftShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(One, 1)
-				.Should().Be(Two);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(MaxValue, 1)
-				.Should().Be(NegativeTwo);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(MinValue, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.LeftShiftOperation(NegativeOne, 1)
-				.Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void op_RightShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(MaxValue, 1)
-				.Should().Be(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(MinValue, 1)
-				.Should().Be(new(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(NegativeOne, 1)
-				.Should().Be(NegativeOne);
-
-			var actual = new Int(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 1)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 2)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 3)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 4)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-					0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 5)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-					0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 6)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.RightShiftOperation(actual, 64 * 7)
-				.Should().Be(new(
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-					0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
-		}
-		[Fact]
-		public static void op_UnsignedRightShiftTest()
-		{
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(MaxValue, 1)
-				.Should().Be(new(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(MinValue, 1)
-				.Should().Be(new(0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			ShiftOperatorsHelper<Int, int, Int>.UnsignedRightShiftOperation(NegativeOne, 1)
-				.Should().Be(MaxValue);
-		}
-
-		[Fact]
-		public static void op_EqualityTest()
-		{
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(Zero, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(One, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(MaxValue, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(MinValue, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.EqualityOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_InequalityTest()
-		{
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(Zero, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(One, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(MaxValue, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(MinValue, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<Int, Int, bool>.InequalityOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void op_GreaterThanTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(MaxValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(MinValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_GreaterThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(MaxValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(MinValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.GreaterThanOrEqualOperation(NegativeOne, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_LessThanTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(MaxValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(MinValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-		[Fact]
-		public static void op_LessThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(MaxValue, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(MinValue, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<Int, Int, bool>.LessThanOrEqualOperation(NegativeOne, 1U).Should().BeTrue();
-		}
-		#endregion
-
-		#region Identities
-		[Fact]
-		public static void AdditiveIdentityTest()
-		{
-			Assert.Equal(Zero, MathConstantsHelper.AdditiveIdentityHelper<Int, Int>());
-		}
-
-		[Fact]
-		public static void MultiplicativeIdentityTest()
-		{
-			Assert.Equal(One, MathConstantsHelper.MultiplicativeIdentityHelper<Int, Int>());
-		}
-		#endregion
-
-		#region IBinaryInteger
-		[Fact]
-		public static void DivRemTest()
-		{
-			Assert.Equal((Zero, Zero), BinaryIntegerHelper<Int>.DivRem(Zero, Two));
-			Assert.Equal((Zero, One), BinaryIntegerHelper<Int>.DivRem(One, Two));
-			Assert.Equal((new Int(0x3FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), One), BinaryIntegerHelper<Int>.DivRem(MaxValue, Two));
-			Assert.Equal((new Int(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), Zero), BinaryIntegerHelper<Int>.DivRem(MinValue, Two));
-			Assert.Equal((Zero, NegativeOne), BinaryIntegerHelper<Int>.DivRem(NegativeOne, 2));
-		}
-
-		[Fact]
-		public static void LeadingZeroCountTest()
-		{
-			Assert.Equal(512, BinaryIntegerHelper<Int>.LeadingZeroCount(Zero));
-			Assert.Equal(511, BinaryIntegerHelper<Int>.LeadingZeroCount(One));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.LeadingZeroCount(MaxValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.LeadingZeroCount(MinValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.LeadingZeroCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void PopCountTest()
-		{
-			Assert.Equal(0, BinaryIntegerHelper<Int>.PopCount(Zero));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.PopCount(One));
-			Assert.Equal(511, BinaryIntegerHelper<Int>.PopCount(MaxValue));
-			Assert.Equal(1, BinaryIntegerHelper<Int>.PopCount(MinValue));
-			Assert.Equal(512, BinaryIntegerHelper<Int>.PopCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void RotateLeftTest()
-		{
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<Int>.RotateLeft(Zero, 1));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002), BinaryIntegerHelper<Int>.RotateLeft(One, 1));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE), BinaryIntegerHelper<Int>.RotateLeft(MaxValue, 1));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), BinaryIntegerHelper<Int>.RotateLeft(MinValue, 1));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), BinaryIntegerHelper<Int>.RotateLeft(NegativeOne, 1));
-		}
-
-		[Fact]
-		public static void RotateRightTest()
-		{
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<Int>.RotateRight(Zero, 1));
-			Assert.Equal(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<Int>.RotateRight(One, 1));
-			Assert.Equal(new(0xBFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), BinaryIntegerHelper<Int>.RotateRight(MaxValue, 1));
-			Assert.Equal(new(0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<Int>.RotateRight(MinValue, 1));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), BinaryIntegerHelper<Int>.RotateRight(NegativeOne, 1));
-		}
-
-		[Fact]
-		public static void TrailingZeroCountTest()
-		{
-			Assert.Equal(512, BinaryIntegerHelper<Int>.TrailingZeroCount(Zero));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(One));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(MaxValue));
-			Assert.Equal(511, BinaryIntegerHelper<Int>.TrailingZeroCount(MinValue));
-			Assert.Equal(0, BinaryIntegerHelper<Int>.TrailingZeroCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt256Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt256Test()
-		{
-			Int result;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.False(BinaryIntegerHelper<Int>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-		}
-
-		[Fact]
-		public static void GetByteCountTest()
-		{
-			Assert.Equal(64, BinaryIntegerHelper<Int>.GetByteCount(Zero));
-			Assert.Equal(64, BinaryIntegerHelper<Int>.GetByteCount(One));
-			Assert.Equal(64, BinaryIntegerHelper<Int>.GetByteCount(MaxValue));
-			Assert.Equal(64, BinaryIntegerHelper<Int>.GetByteCount(MinValue));
-			Assert.Equal(64, BinaryIntegerHelper<Int>.GetByteCount(NegativeOne));
-		}
-
-		[Fact]
-		public static void GetShortestBitLengthTest()
-		{
-			Assert.Equal(0x00, BinaryIntegerHelper<Int>.GetShortestBitLength(Zero));
-			Assert.Equal(0x01, BinaryIntegerHelper<Int>.GetShortestBitLength(One));
-			Assert.Equal(0x1FF, BinaryIntegerHelper<Int>.GetShortestBitLength(MaxValue));
-			Assert.Equal(0x200, BinaryIntegerHelper<Int>.GetShortestBitLength(MinValue));
-			Assert.Equal(0x01, BinaryIntegerHelper<Int>.GetShortestBitLength(NegativeOne));
-		}
-
-		[Fact]
-		public static void TryWriteBigEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[64];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(One, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(MinValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteBigEndian(NegativeOne, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<Int>.TryWriteBigEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-
-		[Fact]
-		public static void TryWriteLittleEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[64];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(One, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(MinValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<Int>.TryWriteLittleEndian(NegativeOne, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<Int>.TryWriteLittleEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-		#endregion
-
-		#region IBinaryNumber
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			Assert.Equal(BinaryNumberHelper<Int>.AllBitsSet, ~Zero);
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x100)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1_0000)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1_0000_0000)));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0, new(0x1, 0x0000_0000_0000_0000))));
-			Assert.True(BinaryNumberHelper<Int>.IsPow2(new(0x1, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000))));
-		}
-		[Fact]
-		public static void Log2Test()
-		{
-			Assert.Equal(8, BinaryNumberHelper<Int>.Log2(new(0x100)));
-			Assert.Equal(16, BinaryNumberHelper<Int>.Log2(new(0x1_0000)));
-			Assert.Equal(32, BinaryNumberHelper<Int>.Log2(new(0x1_0000_0000)));
-			Assert.Equal(64, BinaryNumberHelper<Int>.Log2(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000)));
-			Assert.Equal(128, BinaryNumberHelper<Int>.Log2(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<Int>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			MinValue.Should().Be(MathConstantsHelper.MinValue<Int>());
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<Int>.Clamp(MaxValueMinusOne, Int128MaxValue, MaxValue).Should().Be(MaxValueMinusOne);
-			NumberHelper<Int>.Clamp(MinValue, 0, MaxValue).Should().Be(0);
-			NumberHelper<Int>.Clamp(MaxValue, MinValue, 0).Should().Be(0);
-
-			Assert.Throws<ArgumentException>(() => NumberHelper<Int>.Clamp(MinValue, MaxValue, 0));
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<Int>.CopySign(MaxValue, NegativeOne).Should().Be(MinValuePlusOne);
-			NumberHelper<Int>.CopySign(MaxValue, One).Should().Be(MaxValue);
-			NumberHelper<Int>.CopySign(NegativeTwo, One).Should().Be(Two);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<Int>.Max(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberHelper<Int>.Max(One, NegativeTwo).Should().Be(One);
-			NumberHelper<Int>.Max(Two, NegativeOne).Should().Be(Two);
-			NumberHelper<Int>.Max(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<Int>.MaxNumber(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberHelper<Int>.MaxNumber(One, NegativeTwo).Should().Be(One);
-			NumberHelper<Int>.MaxNumber(Two, NegativeOne).Should().Be(Two);
-			NumberHelper<Int>.MaxNumber(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<Int>.Min(MaxValue, MinValue).Should().Be(MinValue);
-			NumberHelper<Int>.Min(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberHelper<Int>.Min(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberHelper<Int>.Min(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<Int>.MinNumber(MaxValue, MinValue).Should().Be(MinValue);
-			NumberHelper<Int>.MinNumber(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberHelper<Int>.MinNumber(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberHelper<Int>.MinNumber(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<Int>.Sign(MinValue).Should().Be(-1);
-			NumberHelper<Int>.Sign(MaxValue).Should().Be(1);
-			NumberHelper<Int>.Sign(Int.Zero).Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<Int>.Abs(MinValuePlusOne).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.Abs(NegativeTwo).Should().Be(Two);
-			NumberBaseHelper<Int>.Abs(NegativeOne).Should().Be(One);
-			NumberBaseHelper<Int>.Abs(One).Should().Be(One);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Abs(MinValue));
-		}
-		[Fact]
-		public static void CreateCheckedToInt512Test()
-		{
-			NumberBaseHelper<Int>.CreateChecked(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateChecked(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateChecked(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateChecked(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateChecked((double)int.MaxValue).Should().Be(Int32MaxValue);
-
-			NumberBaseHelper<Int>.CreateChecked(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateChecked(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateChecked(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateChecked(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateChecked(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>
-				.CreateChecked(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateChecked((double)int.MinValue).Should().Be(Int32MinValue);
-		}
-		[Fact]
-		public static void CreateSaturatingToInt512Test()
-		{
-			NumberBaseHelper<Int>.CreateSaturating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateSaturating(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int512MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<Int>.CreateSaturating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateSaturating(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>
-				.CreateSaturating(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateSaturating(Int512MinValueAsDouble).Should().Be(MinValue);
-		}
-		[Fact]
-		public static void CreateTruncatingToInt512Test()
-		{
-			NumberBaseHelper<Int>.CreateTruncating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Int>
-				.CreateTruncating(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int512MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<Int>.CreateTruncating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<Int>.CreateTruncating(short.MinValue).Should().Be(Int16MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(int.MinValue).Should().Be(Int32MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(long.MinValue).Should().Be(Int64MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int128.MinValue).Should().Be(Int128MinValue);
-			NumberBaseHelper<Int>
-				.CreateTruncating(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(MinValue);
-			NumberBaseHelper<Int>.CreateTruncating(Int512MinValueAsDouble).Should().Be(MinValue);
-		}
-
-		[Fact]
-		public static void CreateCheckedFromInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateChecked(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateChecked(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateChecked(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateChecked(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateChecked(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
-			NumberBaseHelper<double>.CreateChecked(MaxValue).Should().Be(Int512MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateChecked(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateChecked(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateChecked(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateChecked(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateChecked(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-			NumberBaseHelper<double>.CreateChecked(MinValue).Should().Be(Int512MinValueAsDouble);
-		}
-		[Fact]
-		public static void CreateSaturatingFromInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateSaturating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateSaturating(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateSaturating(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateSaturating(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateSaturating(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
-			NumberBaseHelper<double>.CreateSaturating(MaxValue).Should().Be(Int512MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateSaturating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateSaturating(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateSaturating(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateSaturating(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateSaturating(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-			NumberBaseHelper<double>.CreateSaturating(MinValue).Should().Be(Int512MinValueAsDouble);
-		}
-		[Fact]
-		public static void CreateTruncatingFromInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateTruncating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateTruncating(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateTruncating(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateTruncating(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateTruncating(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
-			NumberBaseHelper<double>.CreateTruncating(MaxValue).Should().Be(Int512MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateTruncating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<short>.CreateTruncating(Int16MinValue).Should().Be(short.MinValue);
-			NumberBaseHelper<int>.CreateTruncating(Int32MinValue).Should().Be(int.MinValue);
-			NumberBaseHelper<long>.CreateTruncating(Int64MinValue).Should().Be(long.MinValue);
-			NumberBaseHelper<Int128>.CreateTruncating(Int128MinValue).Should().Be(Int128.MinValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MinValue).Should()
-				.Be(BigInteger.Parse(
-					"-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-			NumberBaseHelper<double>.CreateTruncating(MinValue).Should().Be(Int512MinValueAsDouble);
-		}
-
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<Int>.IsCanonical(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<Int>.IsComplexNumber(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsEvenInteger(Two).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<Int>.IsFinite(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<Int>.IsImaginaryNumber(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsInfinity(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsInteger(default(Int)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<Int>.IsNaN(default(Int)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<Int>.IsNegative(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsNegative(NegativeOne).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsNegativeInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<Int>.IsNormal(Zero).Should().BeFalse();
-			NumberBaseHelper<Int>.IsNormal(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<Int>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<Int>.IsOddInteger(Two).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<Int>.IsPositive(One).Should().BeTrue();
-			NumberBaseHelper<Int>.IsPositive(NegativeOne).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<Int>.IsPositiveInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<Int>.IsRealNumber(default).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<Int>.IsSubnormal(default).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<Int>.IsZero(default).Should().BeTrue();
-			NumberBaseHelper<Int>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<Int>.IsZero(One).Should().BeFalse();
-			NumberBaseHelper<Int>.IsZero(NegativeOne).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<Int>.MaxMagnitude(MaxValue, MinValue).Should().Be(MinValue);
-			NumberBaseHelper<Int>.MaxMagnitude(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberBaseHelper<Int>.MaxMagnitude(Two, NegativeOne).Should().Be(Two);
-			NumberBaseHelper<Int>.MaxMagnitude(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(MaxValue, MinValue).Should().Be(MinValue);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(One, NegativeTwo).Should().Be(NegativeTwo);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(Two, NegativeOne).Should().Be(Two);
-			NumberBaseHelper<Int>.MaxMagnitudeNumber(NegativeOne, NegativeTwo).Should().Be(NegativeTwo);
-		}
-
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<Int>.MinMagnitude(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.MinMagnitude(One, NegativeTwo).Should().Be(One);
-			NumberBaseHelper<Int>.MinMagnitude(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberBaseHelper<Int>.MinMagnitude(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Int>.MinMagnitudeNumber(MaxValue, MinValue).Should().Be(MaxValue);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(One, NegativeTwo).Should().Be(One);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(Two, NegativeOne).Should().Be(NegativeOne);
-			NumberBaseHelper<Int>.MinMagnitudeNumber(NegativeOne, NegativeTwo).Should().Be(NegativeOne);
-		}
-
-		[Fact]
-		public void ParseTest()
-		{
-			NumberBaseHelper<Int>.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.Parse("7FFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-			NumberBaseHelper<Int>.Parse("8000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseTest()
-		{
-			NumberBaseHelper<Int>.TryParse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out Int parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.TryParse("7FFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.TryParse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-			NumberBaseHelper<Int>.TryParse("8000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000" +
-										"0000000000000000", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-
-			NumberBaseHelper<Int>.TryParse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-			NumberBaseHelper<Int>.TryParse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-
-		[Fact]
-		public void ParseUtf8Test()
-		{
-			NumberBaseHelper<Int>.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.Parse("7FFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF" +
-										"FFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-			NumberBaseHelper<Int>.Parse("8000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<Int>.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseUtf8Test()
-		{
-			NumberBaseHelper<Int>.TryParse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out Int parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.TryParse("7FFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8 +
-										"FFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MaxValue)
-				.And.BeRankedEquallyTo(Int512MaxValue);
-			NumberBaseHelper<Int>.TryParse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-			NumberBaseHelper<Int>.TryParse("8000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8 +
-										"0000000000000000"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(Int512MinValue)
-				.And.BeRankedEquallyTo(Int512MinValue);
-
-			NumberBaseHelper<Int>.TryParse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-			NumberBaseHelper<Int>.TryParse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-		#endregion
-
-		#region ISignedNumber
-		[Fact]
-		public static void NegativeOneTest()
-		{
-			MathConstantsHelper.NegativeOne<Int>().Should().Be(NegativeOne);	
-		}
-		#endregion
-
-		#region IPowerFunctions
-		[Fact]
-		public void PowTest()
-		{
-			GenericFloatingPointFunctions.Pow(Zero, int.MaxValue).Should().Be(Zero);
-			GenericFloatingPointFunctions.Pow(One, int.MaxValue).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, Zero).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, One).Should().Be(MaxValue);
-			GenericFloatingPointFunctions.Pow(Two, Two).Should().Be(4);
-			GenericFloatingPointFunctions.Pow(Two, 4).Should().Be(16);
-			GenericFloatingPointFunctions.Pow(16, Two).Should().Be(256);
-			GenericFloatingPointFunctions.Pow(Two, 510)
-				.Should().Be(new Int(
-					0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-
-			Assert.Throws<ArgumentOutOfRangeException>(() => GenericFloatingPointFunctions.Pow(Two, NegativeOne));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two, 511));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two + Two, 510));
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/Int512Test.cs b/src/MissingValues.Tests/Core/Int512Test.cs
deleted file mode 100644
index 88a9333..0000000
--- a/src/MissingValues.Tests/Core/Int512Test.cs
+++ /dev/null
@@ -1,294 +0,0 @@
-using FluentAssertions;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-using Xunit;
-
-using Int = MissingValues.Int512;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class Int512Test
-	{
-		private static readonly Int Int512MaxValue = new(
-			new UInt256(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF),
-			new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)
-			);
-		private static readonly Int Int512MinValue = new(
-			new UInt256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000),
-			new UInt256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)
-			);
-
-		[Fact]
-		public void Ctor_Empty()
-		{
-			var i = new Int();
-			Assert.Equal(0, i);
-		}
-
-		[Fact]
-		public void Ctor_Value()
-		{
-			var i = new Int(7);
-			Assert.Equal(7, i);
-		}
-
-		[Fact]
-		public void Cast_ToByte()
-		{
-			byte.MinValue.Should().Be((byte)Zero);
-			byte.MaxValue.Should().Be((byte)ByteMaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt16()
-		{
-			short.MinValue.Should().Be((short)Int16MinValue);
-			short.MaxValue.Should().Be((short)Int16MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt32()
-		{
-			int.MinValue.Should().Be((int)Int32MinValue);
-			int.MaxValue.Should().Be((int)Int32MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt64()
-		{
-			long.MinValue.Should().Be((long)Int64MinValue);
-			long.MaxValue.Should().Be((long)Int64MaxValue);
-		}
-		
-		[Fact]
-		public void Cast_ToInt128()
-		{
-			Int128.MinValue.Should().Be((Int128)Int128MinValue);
-			Int128.MaxValue.Should().Be((Int128)Int128MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToInt256()
-		{
-			Int256.MinValue.Should().Be((Int256)Int256MinValue);
-			Int256.MaxValue.Should().Be((Int256)Int256MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.One.Should().Be((BigInteger)One);
-			BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047")
-				.Should().Be((BigInteger)MaxValue);
-			BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048")
-				.Should().Be((BigInteger)MinValue);
-		}
-
-		[Fact]
-		public void Cast_ToDouble()
-		{
-			const double max = 6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047.0;
-			const double min = -6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.0;
-
-			max.Should().Be((double)Int512MaxValue);
-			min.Should().Be((double)Int512MinValue);
-		}
-
-		[Fact]
-		public void ToDecStringTest()
-		{
-			MaxValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047");
-			MinValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048");
-		}
-		[Fact]
-		public void ToHexStringTest()
-		{
-			One.ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((Int)sbyte.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7F");
-			((Int)short.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFF");
-			((Int)int.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFF");
-			((Int)long.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFFFFFFFFFF");
-			((Int)Int128.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-
-			MaxValue.ToString("X128", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("7FFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF" +
-							"FFFFFFFFFFFFFFFF");
-			MinValue.ToString("X128", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("8000000000000000" +
-							"0000000000000000" +
-							"0000000000000000" +
-							"0000000000000000" +
-							"0000000000000000" +
-							"0000000000000000" +
-							"0000000000000000" +
-							"0000000000000000");
-		}
-		[Fact]
-		public void ToBinStringTest()
-		{
-			One.ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((Int)sbyte.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111");
-			((Int)short.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("111111111111111");
-			((Int)int.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111");
-			((Int)long.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("111111111111111111111111111111111111111111111111111111111111111");
-			((Int)Int128.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-
-			MaxValue.ToString("B512", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("011111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"111111111111111111111111111111111" +
-							"11111111111111111111111111111111111111111111111111");
-			MinValue.ToString("B512", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("100000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"000000000000000000000000000000000" +
-							"00000000000000000000000000000000000000000000000000");
-		}
-
-		[Fact]
-		public void ToDecFormatStringTest()
-		{
-			MaxValue.ToString().Should().Be($"{MaxValue:D}");
-			MinValue.ToString().Should().Be($"{MinValue:D}");
-		}
-		[Fact]
-		public void ToHexFormatStringTest()
-		{
-			MaxValue.ToString("X128", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:X128}");
-			MinValue.ToString("X128", CultureInfo.CurrentCulture).Should().Be($"{MinValue:X128}");
-		}
-		[Fact]
-		public void ToBinFormatStringTest()
-		{
-			MaxValue.ToString("B512", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:B512}");
-			MinValue.ToString("B512", CultureInfo.CurrentCulture).Should().Be($"{MinValue:B512}");
-		}
-
-		[Fact]
-		public void ToDecFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString()!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString()!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToHexFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("X128", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:X128}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString("X128", CultureInfo.CurrentCulture)!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:X128}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToBinFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("B512", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:B512}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-
-
-			toString = Encoding.UTF8.GetBytes(MinValue.ToString("B512", CultureInfo.CurrentCulture)!);
-
-			format = stackalloc byte[toString.Length];
-			success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MinValue:B512}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new object[] { MaxValue, MinValue, One, NegativeOne })
-				.Should().Be("[6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047,-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048,1,-1]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			JsonSerializer.Deserialize<Int>("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047")
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<Int>("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"u8)
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<Int>("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048")
-				.Should().Be(MinValue);
-			JsonSerializer.Deserialize<Int>("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8)
-				.Should().Be(MinValue);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/JsonConverterTests.cs b/src/MissingValues.Tests/Core/JsonConverterTests.cs
new file mode 100644
index 0000000..70b4f40
--- /dev/null
+++ b/src/MissingValues.Tests/Core/JsonConverterTests.cs
@@ -0,0 +1,29 @@
+using System.Globalization;
+using System.Text.Json;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Core;
+
+public class JsonConverterTests
+{
+	[Test]
+	public async Task JsonWriteTest()
+	{
+		await Assert.That(JsonSerializer.Serialize(new object[] { UInt256.MaxValue, UInt256.MinValue })).EqualTo($"[{UInt256.MaxValue},{UInt256.MinValue}]");
+		await Assert.That(JsonSerializer.Serialize(new object[] { Int256.MaxValue, Int256.MinValue })).EqualTo($"[{Int256.MaxValue},{Int256.MinValue}]");
+		await Assert.That(JsonSerializer.Serialize(new object[] { UInt512.MaxValue, UInt512.MinValue })).EqualTo($"[{UInt512.MaxValue},{UInt512.MinValue}]");
+		await Assert.That(JsonSerializer.Serialize(new object[] { Int512.MaxValue, Int512.MinValue })).EqualTo($"[{Int512.MaxValue},{Int512.MinValue}]");
+		await Assert.That(JsonSerializer.Serialize(new object[] { Quad.MaxValue, Quad.MinValue })).EqualTo($"[{Quad.MaxValue.ToString("G", CultureInfo.InvariantCulture)},{Quad.MinValue.ToString("G", CultureInfo.InvariantCulture)}]");
+		await Assert.That(JsonSerializer.Serialize(new object[] { Octo.MaxValue, Octo.MinValue })).EqualTo($"[{Octo.MaxValue.ToString("G", CultureInfo.InvariantCulture)},{Octo.MinValue.ToString("G", CultureInfo.InvariantCulture)}]");
+	}
+	[Test]
+	public async Task JsonReadTest()
+	{
+		await Assert.That(JsonSerializer.Deserialize<UInt256>(UInt256.MaxValue.ToString())).EqualTo(UInt256.MaxValue);
+		await Assert.That(JsonSerializer.Deserialize<Int256[]>($"[{Int256.MaxValue},{Int256.MinValue}]")).IsEquivalentTo([Int256.MaxValue, Int256.MinValue]);
+		await Assert.That(JsonSerializer.Deserialize<UInt512>(UInt512.MaxValue.ToString())).EqualTo(UInt512.MaxValue);
+		await Assert.That(JsonSerializer.Deserialize<Int512[]>($"[{Int512.MaxValue},{Int512.MinValue}]")).IsEquivalentTo([Int512.MaxValue, Int512.MinValue]);
+		await Assert.That(JsonSerializer.Deserialize<Quad>(Quad.UInt64MaxValue.ToString("G", CultureInfo.InvariantCulture))).EqualTo(Quad.UInt64MaxValue);
+		await Assert.That(JsonSerializer.Deserialize<Octo>(Octo.UInt64MaxValue.ToString("G", CultureInfo.InvariantCulture))).EqualTo(Octo.UInt64MaxValue);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Core/NumberFormatTest.cs b/src/MissingValues.Tests/Core/NumberFormatTest.cs
deleted file mode 100644
index 7200d85..0000000
--- a/src/MissingValues.Tests/Core/NumberFormatTest.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-using MissingValues.Tests.Helpers;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Core
-{
-	public class NumberFormatTest
-	{
-		private static readonly Quad _decimalSampleValue = Values.CreateFloat<Quad>(0x400C_81CD_6E63_1F8A, 0x0902_DE00_D1B7_1759); // 12345.6789
-		private static readonly NumberFormatInfo CustomInfo = new()
-		{
-			PositiveSign = "+",
-			NegativeSign = "-",
-			CurrencyPositivePattern = 0,
-			CurrencyNegativePattern = 2,
-			CurrencySymbol = "$",
-			CurrencyDecimalDigits = 2,
-			CurrencyDecimalSeparator = ".",
-			CurrencyGroupSeparator = ",",
-			CurrencyGroupSizes = [3],
-			NumberGroupSeparator = "_",
-			NumberGroupSizes = [2],
-			NumberDecimalDigits = 5,
-			NumberDecimalSeparator = ".",
-			NumberNegativePattern = 1,
-			PositiveInfinitySymbol = "+Inf",
-			NegativeInfinitySymbol = "-Inf",
-			NaNSymbol = "NaN",
-		};
-
-		private static readonly (IFormattable, string, NumberFormatInfo?, string)[] _formats =
-		[
-			(Int256.MaxValue, "E", NumberFormatInfo.CurrentInfo, "5,789604E+76"),
-			(Int256.MaxValue, "e25", NumberFormatInfo.CurrentInfo, "5,7896044618658097711785493e+76"),
-			(Int256.MinValue, "E", NumberFormatInfo.CurrentInfo, "-5,789604E+76"),
-			(Int256.MinValue, "e25", NumberFormatInfo.CurrentInfo, "-5,7896044618658097711785493e+76"),
-			(Int512.MaxValue, "E", NumberFormatInfo.CurrentInfo, "6,703904E+153"),
-			(Int512.MaxValue, "e25", NumberFormatInfo.CurrentInfo, "6,7039039649712985497870125e+153"),
-			(Int512.MinValue, "E", NumberFormatInfo.CurrentInfo, "-6,703904E+153"),
-			(Int512.MinValue, "e25", NumberFormatInfo.CurrentInfo, "-6,7039039649712985497870125e+153"),
-			(Int512.MinValue, "F3", NumberFormatInfo.InvariantInfo, "-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000"),
-			(_decimalSampleValue, "F", NumberFormatInfo.InvariantInfo, "12345.68"),
-			(_decimalSampleValue, "F", CustomInfo, "12345.67890"),
-			(Int512.MinValue, "N", NumberFormatInfo.InvariantInfo, "-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00"),
-			(_decimalSampleValue, "N3", NumberFormatInfo.InvariantInfo, "12,345.679"),
-			(_decimalSampleValue, "N", CustomInfo, "1_23_45.67890"),
-			(Int512.MinValue, "C", CustomInfo, "$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00"),
-			(_decimalSampleValue, "C", CustomInfo, "$12,345.68"),
-		];
-		private static readonly (string, NumberStyles, NumberFormatInfo?, Int512, bool)[] _parseInt512 =
-		[
-			("1E200", NumberStyles.Number | NumberStyles.AllowExponent, NumberFormatInfo.CurrentInfo, default, false),
-			("2,5E10", NumberStyles.Number | NumberStyles.AllowExponent, NumberFormatInfo.CurrentInfo, 25_000_000_000, true),
-			("1E10", NumberStyles.Number | NumberStyles.AllowExponent, NumberFormatInfo.CurrentInfo, 10_000_000_000, true),
-			("1,000", NumberStyles.Number, NumberFormatInfo.CurrentInfo, Int512.One, true),
-			("1.000,0", NumberStyles.Number, NumberFormatInfo.CurrentInfo, 1_000, true),
-			("1.000.000", NumberStyles.Number, NumberFormatInfo.CurrentInfo, 1_000_000, true),
-			("1.000.000.000,00", NumberStyles.Number, NumberFormatInfo.CurrentInfo, 1_000_000_000, true),
-			("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000", NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue, true),
-			("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048", NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue, true),
-			("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00", NumberStyles.Currency, CustomInfo, Int512.MinValue, true),
-		];
-		private static readonly (string, NumberStyles, NumberFormatInfo?, Quad, bool)[] _parseQuad =
-		[
-			("2,5E-1", NumberStyles.Float, NumberFormatInfo.CurrentInfo, QuadTest.Quarter, true),
-			("0,250", NumberStyles.Float, NumberFormatInfo.CurrentInfo, QuadTest.Quarter, true),
-			("$-0.25", NumberStyles.Currency, CustomInfo, QuadTest.NegativeQuarter, true),
-			("1,000", NumberStyles.Float, NumberFormatInfo.CurrentInfo, Quad.One, true),
-			("1.000,0", NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, QuadTest.Thousand, true),
-			("-1.000,0", NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, QuadTest.NegativeThousand, true),
-		];
-
-		public static readonly FormatStringTheoryData FormatsTheoryData = new(_formats);
-
-		public static readonly FormatParsingTheoryData<Int512> ParseInt512TheoryData = new(_parseInt512);
-		public static readonly FormatParsingTheoryData<Quad> ParseQuadTheoryData = new(_parseQuad);
-
-		[Theory]
-		[MemberData(nameof(FormatsTheoryData))]
-		public void FormattingTest(IFormattable value, string fmt, NumberFormatInfo? info, string expected)
-		{
-			string actual = value.ToString(fmt, info);
-			actual.Should().Be(expected);
-		}
-		[Theory]
-		[MemberData(nameof(ParseInt512TheoryData))]
-		public void IntegerParsingTest(string s, NumberStyles style, NumberFormatInfo? info, Int512 expected, bool success)
-		{
-			Int512.TryParse(s, style, info, out Int512 actual).Should().Be(success);
-			actual.Should().Be(expected);
-		}
-		[Theory]
-		[MemberData(nameof(ParseQuadTheoryData))]
-		public void FloatingPointParsingTest(string s, NumberStyles style, NumberFormatInfo? info, Quad expected, bool success)
-		{
-			Quad.TryParse(s, style, info, out Quad actual).Should().Be(success);
-			actual.Should().Be(expected);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/OctoTest.GenericMath.cs b/src/MissingValues.Tests/Core/OctoTest.GenericMath.cs
deleted file mode 100644
index 8778d68..0000000
--- a/src/MissingValues.Tests/Core/OctoTest.GenericMath.cs
+++ /dev/null
@@ -1,921 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-using Float = MissingValues.Octo;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class OctoTest
-	{
-		#region Generic Math Operators
-		[Theory]
-		[MemberData(nameof(UnaryNegationOperationTheoryData))]
-		public static void op_UnaryNegationTest(Float self, Float result)
-		{
-			MathOperatorsHelper.UnaryNegationOperation<Float, Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(AdditionOperationTheoryData))]
-		public static void op_AdditionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.AdditionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(IncrementOperationTheoryData))]
-		public static void op_IncrementTest(Float self, Float result)
-		{
-			MathOperatorsHelper.IncrementOperation<Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(SubtractionOperationTheoryData))]
-		public static void op_SubtractionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.SubtractionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(DecrementOperationTheoryData))]
-		public static void op_DecrementTest(Float self, Float result)
-		{
-			MathOperatorsHelper.DecrementOperation<Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(MultiplicationOperationTheoryData))]
-		public static void op_MultiplicationTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.MultiplicationOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(DivisionOperationTheoryData))]
-		public static void op_DivisionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.DivisionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		#endregion
-
-		#region IBinaryFloatingPointIEEE
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			BinaryNumberHelper<Float>.AllBitsSet.Should().Be(BitwiseOperatorsHelper<Float, Float, Float>.OnesComplementOperation(Zero));
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			BinaryNumberHelper<Float>.IsPow2(Half).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(One).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(Two).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(Three).Should().BeFalse();
-			BinaryNumberHelper<Float>.IsPow2(NegativeTwo).Should().BeFalse();
-		}
-		#endregion
-
-		#region IFloatingPointIEEE
-		[Fact]
-		public static void EpsilonTest()
-		{
-			FloatingPointIeee754<Float>.Epsilon.Should().Be(Float.Epsilon);
-			MathOperatorsHelper.AdditionOperation<Float, Float, Float>(FloatingPointIeee754<Float>.Epsilon, NumberBaseHelper<Float>.Zero)
-				.Should().NotBe(Float.Zero);
-		}
-		[Fact]
-		public static void NaNTest()
-		{
-			FloatingPointIeee754<Float>.NaN
-				.Should().Be(Float.NaN)
-				.And.BeNaN();
-			NumberBaseHelper<Float>.IsNaN(FloatingPointIeee754<Float>.NaN).Should().BeTrue();
-		}
-		[Fact]
-		public static void NegativeInfinityTest()
-		{
-			FloatingPointIeee754<Float>.NegativeInfinity.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.IsInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegativeInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositiveInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void PositiveInfinityTest()
-		{
-			FloatingPointIeee754<Float>.PositiveInfinity.Should().Be(Float.PositiveInfinity);
-			NumberBaseHelper<Float>.IsInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegativeInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void BitDecrementTest()
-		{
-			FloatingPointIeee754<Float>.BitDecrement(One)
-				.Should().Be(Values.CreateFloat<Float>(0x3FFFEFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
-			FloatingPointIeee754<Float>.BitDecrement(NegativeOne)
-				.Should().Be(Values.CreateFloat<Float>(0xBFFFF00000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001));
-			FloatingPointIeee754<Float>.BitDecrement(Zero)
-				.Should().Be(-Float.Epsilon);
-			FloatingPointIeee754<Float>.BitDecrement(Float.NegativeInfinity)
-				.Should().Be(Float.NegativeInfinity);
-			FloatingPointIeee754<Float>.BitDecrement(Float.PositiveInfinity)
-				.Should().Be(Float.MaxValue);
-		}
-		[Fact]
-		public static void BitIncrementTest()
-		{
-			FloatingPointIeee754<Float>.BitIncrement(One)
-				.Should().Be(Values.CreateFloat<Float>(0x3FFFF00000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001));
-			FloatingPointIeee754<Float>.BitIncrement(NegativeOne)
-				.Should().Be(Values.CreateFloat<Float>(0xBFFFEFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
-			FloatingPointIeee754<Float>.BitIncrement(NegativeZero)
-				.Should().Be(Float.Epsilon);
-			FloatingPointIeee754<Float>.BitIncrement(Float.NegativeInfinity)
-				.Should().Be(Float.MinValue);
-			FloatingPointIeee754<Float>.BitIncrement(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Theory]
-		[MemberData(nameof(FMATheoryData))]
-		public static void FusedMultiplyAddTest(Float left, Float right, Float addend, Float result)
-		{
-			FloatingPointIeee754<Float>.FusedMultiplyAdd(left, right, addend)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Fact]
-		public static void IeeeRemainderTest()
-		{
-			FloatingPointIeee754<Float>.Ieee754Remainder(Ten, Three).Should().Be(One);
-			FloatingPointIeee754<Float>.Ieee754Remainder(Ten, Two).Should().Be(Zero);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Three).Should().Be(NegativeOne);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Two).Should().Be(NegativeZero);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Zero).Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void ILogBTest()
-		{
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0x4000_9000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(10);
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0x4003_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(64);
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0x4007_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(128);
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0xC003_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(64);
-			FloatingPointIeee754<Float>.ILogB(Zero)
-				.Should().Be(int.MinValue);
-		}
-		[Fact]
-		public static void ReciprocalEstimateTest()
-		{
-			FloatingPointIeee754<Float>.ReciprocalEstimate(Two)
-				.Should().Be(Half);
-			FloatingPointIeee754<Float>.ReciprocalEstimate(Four)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), Delta);
-		}
-		[Fact]
-		public static void ScaleBTest()
-		{
-			FloatingPointIeee754<Float>.ScaleB(Two, 3)
-				.Should().Be(Values.CreateFloat<Float>(0x4000_3000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			FloatingPointIeee754<Float>.ScaleB(NegativeTwo, 3)
-				.Should().Be(Values.CreateFloat<Float>(0xC000_3000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-			FloatingPointIeee754<Float>.ScaleB(Zero, 6)
-				.Should().Be(Zero);
-			FloatingPointIeee754<Float>.ScaleB(Two, 300000)
-				.Should().Be(Float.PositiveInfinity);
-			FloatingPointIeee754<Float>.ScaleB(Two, -300000)
-				.Should().Be(Zero);
-		}
-		[Fact]
-		public static void SqrtTest()
-		{
-			GenericFloatingPointFunctions.Sqrt(Zero)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Sqrt(-Zero)
-				.Should().Be(-Zero);
-			GenericFloatingPointFunctions.Sqrt(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Sqrt(NegativeFour)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Sqrt(Float.NaN)
-				.Should().Be(Float.NaN);
-
-			GenericFloatingPointFunctions.Sqrt(Hundred)
-				.Should().BeApproximately(Ten, Delta);
-		}
-		#endregion
-
-		#region IFloatingPoint
-		[Theory]
-		[MemberData(nameof(RoundAwayFromZeroTheoryData))]
-		[MemberData(nameof(RoundToEvenTheoryData))]
-		[MemberData(nameof(RoundToNegativeInfinityTheoryData))]
-		[MemberData(nameof(RoundToPositiveInfinityTheoryData))]
-		[MemberData(nameof(RoundToZeroTheoryData))]
-		public static void RoundTest(Float self, int digits, MidpointRounding midpointRounding, Float result)
-		{
-			Float.Round(self, digits, midpointRounding).Should().Be(result);
-		}
-		#endregion
-
-		#region IFloatingPointConstants
-		[Fact]
-		public static void ConstantPiTest()
-		{
-			Assert.Equal(Float.Pi, MathConstantsHelper.Pi<Float>());
-		}
-		[Fact]
-		public static void ConstantTauTest()
-		{
-			Assert.Equal(Float.Tau, MathConstantsHelper.Tau<Float>());
-		}
-		[Fact]
-		public static void ConstantETest()
-		{
-			Assert.Equal(Float.E, MathConstantsHelper.E<Float>());
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<Float>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			MinValue.Should().Be(MathConstantsHelper.MinValue<Float>());
-		}
-		#endregion
-
-		#region ISignedNumber
-		[Fact]
-		public static void NegativeOneTest()
-		{
-			MathConstantsHelper.NegativeOne<Float>().Should().Be(NegativeOne);
-			MathConstantsHelper.NegativeOne<Float>().Should().Be(-One);
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<Float>.Clamp(Float.NegativeInfinity, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.MinValue, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(NegativeOne, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(-GreatestSubnormal, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(-Float.Epsilon, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(NegativeZero, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.NaN, One, Thousand)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Clamp(Zero, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.Epsilon, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(GreatestSubnormal, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(One, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.MaxValue, One, Thousand)
-				.Should().Be(Thousand);
-			NumberHelper<Float>.Clamp(Float.PositiveInfinity, One, Thousand)
-				.Should().Be(Thousand);
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<Float>.CopySign(One, NegativeOne)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.CopySign(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.CopySign(Thousand, NegativeOne)
-				.Should().Be(NegativeThousand);
-			NumberHelper<Float>.CopySign(NegativeHundred, NegativeOne)
-				.Should().Be(NegativeHundred);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<Float>.Max(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.MinValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(NegativeZero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Max(Zero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberHelper<Float>.Max(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<Float>.MaxNumber(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.MinValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(NegativeZero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Zero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberHelper<Float>.MaxNumber(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<Float>.Min(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberHelper<Float>.Min(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberHelper<Float>.Min(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.Min(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberHelper<Float>.Min(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberHelper<Float>.Min(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberHelper<Float>.Min(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Min(Zero, One)
-				.Should().Be(Zero);
-			NumberHelper<Float>.Min(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberHelper<Float>.Min(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberHelper<Float>.Min(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Min(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Min(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<Float>.MinNumber(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberHelper<Float>.MinNumber(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberHelper<Float>.MinNumber(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.MinNumber(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberHelper<Float>.MinNumber(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberHelper<Float>.MinNumber(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberHelper<Float>.MinNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Zero, One)
-				.Should().Be(Zero);
-			NumberHelper<Float>.MinNumber(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberHelper<Float>.MinNumber(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberHelper<Float>.MinNumber(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<Float>.Sign(One)
-				.Should().Be(1);
-			NumberHelper<Float>.Sign(NegativeOne)
-				.Should().Be(-1);
-			NumberHelper<Float>.Sign(Ten)
-				.Should().Be(1);
-			NumberHelper<Float>.Sign(NegativeTen)
-				.Should().Be(-1);
-			NumberHelper<Float>.Sign(Zero)
-				.Should().Be(0);
-			NumberHelper<Float>.Sign(NegativeZero)
-				.Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void OneTest()
-		{
-			Assert.Equal(One, NumberBaseHelper<Float>.One);
-		}
-		[Fact]
-		public static void ZeroTest()
-		{
-			Assert.Equal(Zero, NumberBaseHelper<Float>.Zero);
-		}
-		[Fact]
-		public static void RadixTest()
-		{
-			Assert.Equal(Radix, NumberBaseHelper<Float>.Radix);
-		}
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<Float>.Abs(One).Should().Be(One);
-			NumberBaseHelper<Float>.Abs(NegativeOne).Should().Be(One);
-			NumberBaseHelper<Float>.Abs(NegativeHalf).Should().Be(Half);
-			NumberBaseHelper<Float>.Abs(NegativeQuarter).Should().Be(Quarter);
-			NumberBaseHelper<Float>.Abs(NegativeZero).Should().Be(Zero);
-			NumberBaseHelper<Float>.Abs(Float.NegativeInfinity).Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void CreateCheckedFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateChecked<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateChecked<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateChecked<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateChecked<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateChecked<Float>(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateChecked<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateChecked<Float>(TwoOver511)
-				.Should()
-				.Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateChecked<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateChecked<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateChecked<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateSaturatingFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateSaturating<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateSaturating<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateSaturating<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateSaturating<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateSaturating<Float>(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateSaturating<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateSaturating<Float>(TwoOver511)
-				.Should()
-				.Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateSaturating<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateSaturating<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateSaturating<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateTruncatingFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateTruncating<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateTruncating<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateTruncating<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateTruncating<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<Int128>.CreateTruncating<Float>(Int128MaxValue).Should().Be(Int128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateTruncating<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateTruncating<Float>(TwoOver511)
-				.Should()
-				.Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateTruncating<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateTruncating<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateTruncating<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateCheckedToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateChecked<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateChecked<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<Int128>(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateChecked<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateChecked<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateChecked<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateChecked<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void CreateSaturatingToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateSaturating<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<Int128>(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateSaturating<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateSaturating<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateSaturating<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateSaturating<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void CreateTruncatingToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateTruncating<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<Int128>(Int128.MaxValue).Should().Be(Int128MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateTruncating<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateTruncating<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateTruncating<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateTruncating<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<Float>.IsCanonical(One).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<Float>.IsComplexNumber(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsEvenInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(Two).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(Three).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(Four).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeTwo).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeThree).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeFour).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<Float>.IsFinite(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsFinite(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsFinite(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsFinite(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsFinite(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<Float>.IsImaginaryNumber(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInfinity(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsInteger(Quarter).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Thousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(GreaterThanOneSmallest).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(SmallestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(NegativeThousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(NegativeHalf).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(NegativeQuarter).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<Float>.IsNaN(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(Float.NaN).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNaN(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<Float>.IsNegative(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(GreatestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(Float.NaN).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegative(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegative(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsNegativeInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<Float>.IsNormal(GreatestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNormal(SmallestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNormal(MaxValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNormal(MinValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNormal(One).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsOddInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(Two).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(Three).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(Four).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeTwo).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeThree).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeFour).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<Float>.IsPositive(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositive(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositive(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsPositiveInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<Float>.IsRealNumber(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(MaxValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(NegativeThousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.NaN).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<Float>.IsSubnormal(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsSubnormal(SmallestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsSubnormal(MaxValue).Should().BeFalse();
-			NumberBaseHelper<Float>.IsSubnormal(MinValue).Should().BeFalse();
-			NumberBaseHelper<Float>.IsSubnormal(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<Float>.IsZero(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsZero(Float.Epsilon).Should().BeFalse();
-			NumberBaseHelper<Float>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<Float>.IsZero(NegativeZero).Should().BeTrue();
-		}
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<Float>.MaxMagnitude(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberBaseHelper<Float>.MaxMagnitude(NegativeOne, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(NegativeZero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberBaseHelper<Float>.MaxMagnitude(Zero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(NegativeOne, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(NegativeZero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Zero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<Float>.MinMagnitude(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.MinValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberBaseHelper<Float>.MinMagnitude(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitude(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitude(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberBaseHelper<Float>.MinMagnitude(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberBaseHelper<Float>.MinMagnitude(Zero, One)
-				.Should().Be(Zero);
-			NumberBaseHelper<Float>.MinMagnitude(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitude(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitude(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.MinValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Zero, One)
-				.Should().Be(Zero);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void ParseTest(string s, bool success, Float output)
-		{
-			if (success)
-			{
-				NumberBaseHelper<Float>.Parse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo)
-					.Should().Be(output);
-			}
-			else
-			{
-				Assert.Throws<FormatException>(() => NumberBaseHelper<Float>.Parse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo));
-			}
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void TryParseTest(string s, bool success, Float output)
-		{
-			Float result;
-
-			NumberBaseHelper<Float>.TryParse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out result).Should().Be(success);
-			result.Should().Be(output);
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void ParseUtf8Test(string s, bool success, Float output)
-		{
-			byte[] utf8 = Encoding.UTF8.GetBytes(s);
-
-			if (success)
-			{
-				NumberBaseHelper<Float>.Parse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo)
-					.Should().Be(output);
-			}
-			else
-			{
-				Assert.Throws<FormatException>(() => NumberBaseHelper<Float>.Parse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo));
-			}
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void TryParseUtf8Test(string s, bool success, Float output)
-		{
-			ReadOnlySpan<byte> utf8 = Encoding.UTF8.GetBytes(s);
-			Float result;
-
-			NumberBaseHelper<Float>.TryParse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out result).Should().Be(success);
-			result.Should().Be(output);
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/OctoTest.TheoryData.cs b/src/MissingValues.Tests/Core/OctoTest.TheoryData.cs
deleted file mode 100644
index 0c7c093..0000000
--- a/src/MissingValues.Tests/Core/OctoTest.TheoryData.cs
+++ /dev/null
@@ -1,780 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class OctoTest
-	{
-#pragma warning disable S3263 // Static fields should appear in the order they must be initialized 
-		private static (string, bool, Octo)[] _tryParseData =>
-		[
-			("10,0", true, Ten),
-			("3", true, Three),
-			("-3", true, NegativeThree),
-			("2,0", true, Two),
-			("-2", true, NegativeTwo),
-			("0", true, Zero),
-			("-0", true, NegativeZero),
-			(NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol, true, Octo.PositiveInfinity),
-			(NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol, true, Octo.NegativeInfinity),
-			(NumberFormatInfo.CurrentInfo.NaNSymbol, true, Octo.NaN),
-		];
-
-		private static (Octo, Octo)[] _unaryNegationOperationData =>
-		[
-			(Zero, NegativeZero),
-			(One, NegativeOne),
-			(Two, NegativeTwo),
-			(Ten, NegativeTen),
-			(Hundred, NegativeHundred),
-			(Thousand, NegativeThousand)
-		];
-		private static (Octo, Octo)[] _incrementOperationData =>
-		[
-			(NegativeTwo, NegativeOne),
-			(NegativeOne, Zero),
-			(Zero, One),
-			(One, Two),
-		];
-		private static (Octo, Octo)[] _decrementOperationData =>
-		[
-			(NegativeOne, NegativeTwo),
-			(Zero, NegativeOne),
-			(One, Zero),
-			(Two, One),
-		];
-
-		private static (Octo, Octo, Octo)[] _additionOperationData =>
-		[
-			(One, One, Two),
-			(One, NegativeOne, Zero),
-			(One, NegativeTwo, NegativeOne),
-			(One, Four, Five),
-			(Three, Two, Five),
-			(SmallestSubnormal, GreatestSubnormal, Values.CreateFloat<Octo>(0x0000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)),
-			(Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity),
-			(Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity),
-			(Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.PositiveInfinity),
-			(Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NegativeInfinity),
-		];
-		private static (Octo, Octo, Octo)[] _subtractionOperationData =>
-		[
-			(One, One, Zero),
-			(One, NegativeOne, Two),
-			(One, Two, NegativeOne),
-			(SmallestSubnormal, GreatestSubnormal, Values.CreateFloat<Octo>(0x8000_0FFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)),
-			(Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.NaN),
-			(Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NaN),
-		];
-		private static (Octo, Octo, Octo)[] _multiplicationOperationData =>
-		[
-			(One, One, One),
-			(One, NegativeOne, NegativeOne),
-			(Ten, Ten, Hundred),
-			(NegativeHundred, Ten, NegativeThousand),
-			(NegativeTen, Hundred, NegativeThousand),
-			(Zero, NegativeThousand, NegativeZero),
-			(Zero, Octo.PositiveInfinity, Octo.NaN),
-			(NegativeZero, Octo.NegativeInfinity, Octo.NaN),
-			(Octo.PositiveInfinity, Zero, Octo.NaN),
-			(Octo.NegativeInfinity, NegativeZero, Octo.NaN),
-		];
-		private static (Octo, Octo, Octo)[] _divisionOperationData =>
-		[
-			(One, Two, Half),
-			(One, Four, Quarter),
-			(Ten, Five, Two),
-			(Ten, Ten, One),
-			(Hundred, Ten, Ten),
-			(NegativeThousand, Ten, NegativeHundred),
-			(Zero, Zero, Octo.NaN),
-			(One, Zero, Octo.PositiveInfinity),
-			(NegativeOne, Zero, Octo.NegativeInfinity),
-			(Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.NaN),
-			(Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NaN),
-		];
-
-		private static (byte, Octo)[] _castFromByteData =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(byte.MaxValue, ByteMaxValue),
-		];
-		private static (ushort, Octo)[] _castFromUInt16Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-		];
-		private static (uint, Octo)[] _castFromUInt32Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-		];
-		private static (ulong, Octo)[] _castFromUInt64Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-		];
-		private static (UInt128, Octo)[] _castFromUInt128Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-			(UInt128.MaxValue, UInt128MaxValue),
-		];
-		private static (UInt256, Octo)[] _castFromUInt256Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-			(UInt128.MaxValue, UInt128MaxValue),
-		];
-		private static (UInt512, Octo)[] _castFromUInt512Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-			(UInt128.MaxValue, UInt128MaxValue),
-		];
-		private static (sbyte, Octo)[] _castFromSByteData =>
-		[
-			(sbyte.MinValue, SByteMinValue),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(sbyte.MaxValue, SByteMaxValue),
-		];
-		private static (short, Octo)[] _castFromInt16Data =>
-		[
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-		];
-		private static (int, Octo)[] _castFromInt32Data =>
-		[
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-		];
-		private static (long, Octo)[] _castFromInt64Data =>
-		[
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-		];
-		private static (Int128, Octo)[] _castFromInt128Data =>
-		[
-			(Int128.MinValue, Int128MinValue),
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-			(Int128.MaxValue, Int128MaxValue),
-		];
-		private static (Int256, Octo)[] _castFromInt256Data =>
-		[
-			(Int128.MinValue, Int128MinValue),
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-			(Int128.MaxValue, Int128MaxValue),
-		];
-		private static (Int512, Octo)[] _castFromInt512Data =>
-		[
-			(Int128.MinValue, Int128MinValue),
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-			(Int128.MaxValue, Int128MaxValue),
-		];
-		private static (Half, Octo)[] _castFromHalfData =>
-		[
-			(System.Half.NegativeOne, NegativeOne),
-			(System.Half.NegativeZero, NegativeZero),
-			(System.Half.Zero, Zero),
-			(System.Half.One, One),
-			((Half)10, Ten),
-			((Half)100, Hundred),
-			((Half)1000, Thousand),
-		];
-		private static (float, Octo)[] _castFromSingleData =>
-		[
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-		];
-		private static (double, Octo)[] _castFromDoubleData =>
-		[
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-		];
-
-		private static (Octo, byte)[] _castToByteData =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(ByteMaxValue, byte.MaxValue),
-		];
-		private static (Octo, ushort)[] _castToUInt16Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-		];
-		private static (Octo, uint)[] _castToUInt32Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-		];
-		private static (Octo, ulong)[] _castToUInt64Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-		];
-		private static (Octo, UInt128)[] _castToUInt128Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-			(UInt128MaxValue, UInt128.MaxValue),
-		];
-		private static (Octo, UInt256)[] _castToUInt256Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-			(UInt128MaxValue, UInt128.MaxValue),
-		];
-		private static (Octo, UInt512)[] _castToUInt512Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-			(UInt128MaxValue, UInt128.MaxValue),
-		];
-		private static (Octo, sbyte)[] _castToSByteData =>
-		[
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-		];
-		private static (Octo, short)[] _castToInt16Data =>
-		[
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-		];
-		private static (Octo, int)[] _castToInt32Data =>
-		[
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-		];
-		private static (Octo, long)[] _castToInt64Data =>
-		[
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-		];
-		private static (Octo, Int128)[] _castToInt128Data =>
-		[
-			(Int128MinValue, Int128.MinValue),
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-			(Int128MaxValue, Int128.MaxValue),
-		];
-		private static (Octo, Int256)[] _castToInt256Data =>
-		[
-			(Int128MinValue, Int128.MinValue),
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-			(Int128MaxValue, Int128.MaxValue),
-		];
-		private static (Octo, Int512)[] _castToInt512Data =>
-		[
-			(Int128MinValue, Int128.MinValue),
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-			(Int128MaxValue, Int128.MaxValue),
-		];
-		private static (Octo, Half)[] _castToHalfData =>
-		[
-			(NegativeHundred, -(Half)100.0f),
-			(NegativeTen, -(Half)10.0f),
-			(NegativeTwo, -(Half)2.0f),
-			(NegativeOne, -(Half)1.0f),
-			(NegativeZero, -(Half)0.0f),
-			(Zero, (Half)0.0f),
-			(One, System.Half.One),
-			(Two, (Half)2.0f),
-			(Ten, (Half)10.0f),
-			(Hundred, (Half)100.0f),
-		];
-		private static (Octo, float)[] _castToSingleData =>
-		[
-			(NegativeThousand, -1000.0f),
-			(NegativeHundred, -100.0f),
-			(NegativeTen, -10.0f),
-			(NegativeTwo, -2.0f),
-			(NegativeOne, -1.0f),
-			(NegativeZero, -0.0f),
-			(Zero, 0.0f),
-			(Half, 0.5f),
-			(One, 1.0f),
-			(Two, 2.0f),
-			(Ten, 10.0f),
-			(Hundred, 100.0f),
-			(Thousand, 1000.0f),
-		];
-		private static (Octo, double)[] _castToDoubleData =>
-		[
-			(NegativeThousand, -1000.0d),
-			(NegativeHundred, -100.0d),
-			(NegativeTen, -10.0d),
-			(NegativeTwo, -2.0d),
-			(NegativeOne, -1.0d),
-			(NegativeZero, -0.0d),
-			(Zero, 0.0d),
-			(Half, 0.5d),
-			(One, 1.0d),
-			(Two, 2.0d),
-			(Ten, 10.0d),
-			(Hundred, 100.0d),
-			(Thousand, 1000.0d),
-		];
-		private static (Octo, Quad)[] _castToQuadData =>
-		[
-			(NegativeThousand, QuadTest.NegativeThousand),
-			(NegativeHundred, QuadTest.NegativeHundred),
-			(NegativeTen, QuadTest.NegativeTen),
-			(NegativeTwo, QuadTest.NegativeTwo),
-			(NegativeOne, QuadTest.NegativeOne),
-			(NegativeZero, QuadTest.NegativeZero),
-			(Zero, QuadTest.Zero),
-			(Half, QuadTest.Half),
-			(One, QuadTest.One),
-			(Two, QuadTest.Two),
-			(Ten, QuadTest.Ten),
-			(Hundred, QuadTest.Hundred),
-			(Thousand, QuadTest.Thousand),
-		];
-
-		private static (Octo, int, MidpointRounding, Octo)[] _roundAwayFromZeroData =>
-		[
-			(Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Four),
-			(Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Three),
-			(Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Three),
-			(Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Two),
-			(Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, NegativeFour),
-		];
-		private static (Octo, int, MidpointRounding, Octo)[] _roundToEvenData =>
-		[
-			(Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Four),
-			(Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Three),
-			(Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Two),
-			(Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Two),
-			(Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, NegativeFour),
-		];
-		private static (Octo, int, MidpointRounding, Octo)[] _roundToNegativeInfinityData =>
-		[
-			(Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Three),
-			(Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, NegativeFour),
-		];
-		private static (Octo, int, MidpointRounding, Octo)[] _roundToPositiveInfinityData =>
-		[
-			(Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Four),
-			(Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, NegativeThree),
-		];
-		private static (Octo, int, MidpointRounding, Octo)[] _roundToZeroData =>
-		[
-			(Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Three),
-			(Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, NegativeThree),
-		];
-
-		private static (Octo, Octo, Octo, Octo)[] _fmaData =>
-		[
-			(One, One, One, Two),
-			(Ten, Ten, Zero, Hundred),
-			(Five, Zero, Five, Five),
-			(Half, Two, Two, Three),
-			(Two, Four, Two, Ten),
-			(Ten, Half, Five, Ten),
-			(Values.CreateFloat<Octo>(13835044861142630400, 0, 0, 0), One, Two, Values.CreateFloat<Octo>(0x3FFF_E800_0000_0000, 0, 0, 0)),
-		];
-
-
-		public static TryParseTheoryData<Octo> TryParseTheoryData = new(_tryParseData);
-
-		public static UnaryTheoryData<Octo, Octo> UnaryNegationOperationTheoryData = new(_unaryNegationOperationData);
-		public static UnaryTheoryData<Octo, Octo> IncrementOperationTheoryData = new(_incrementOperationData);
-		public static UnaryTheoryData<Octo, Octo> DecrementOperationTheoryData = new(_decrementOperationData);
-
-		public static OperationTheoryData<Octo, Octo, Octo> AdditionOperationTheoryData = new(_additionOperationData);
-		public static OperationTheoryData<Octo, Octo, Octo> SubtractionOperationTheoryData = new(_subtractionOperationData);
-		public static OperationTheoryData<Octo, Octo, Octo> MultiplicationOperationTheoryData = new(_multiplicationOperationData);
-		public static OperationTheoryData<Octo, Octo, Octo> DivisionOperationTheoryData = new(_divisionOperationData);
-
-		public static CastingTheoryData<byte, Octo> CastFromByteTheoryData = new(_castFromByteData);
-		public static CastingTheoryData<ushort, Octo> CastFromUInt16TheoryData = new(_castFromUInt16Data);
-		public static CastingTheoryData<uint, Octo> CastFromUInt32TheoryData = new(_castFromUInt32Data);
-		public static CastingTheoryData<ulong, Octo> CastFromUInt64TheoryData = new(_castFromUInt64Data);
-		public static CastingTheoryData<UInt128, Octo> CastFromUInt128TheoryData = new(_castFromUInt128Data);
-		public static CastingTheoryData<UInt256, Octo> CastFromUInt256TheoryData = new(_castFromUInt256Data);
-		public static CastingTheoryData<UInt512, Octo> CastFromUInt512TheoryData = new(_castFromUInt512Data);
-		public static CastingTheoryData<sbyte, Octo> CastFromSByteTheoryData = new(_castFromSByteData);
-		public static CastingTheoryData<short, Octo> CastFromInt16TheoryData = new(_castFromInt16Data);
-		public static CastingTheoryData<int, Octo> CastFromInt32TheoryData = new(_castFromInt32Data);
-		public static CastingTheoryData<long, Octo> CastFromInt64TheoryData = new(_castFromInt64Data);
-		public static CastingTheoryData<Int128, Octo> CastFromInt128TheoryData = new(_castFromInt128Data);
-		public static CastingTheoryData<Int256, Octo> CastFromInt256TheoryData = new(_castFromInt256Data);
-		public static CastingTheoryData<Int512, Octo> CastFromInt512TheoryData = new(_castFromInt512Data);
-		public static CastingTheoryData<Half, Octo> CastFromHalfTheoryData = new(_castFromHalfData);
-		public static CastingTheoryData<float, Octo> CastFromSingleTheoryData = new(_castFromSingleData);
-		public static CastingTheoryData<double, Octo> CastFromDoubleTheoryData = new(_castFromDoubleData);
-
-		public static CastingTheoryData<Octo, byte> CastToByteTheoryData = new(_castToByteData);
-		public static CastingTheoryData<Octo, ushort> CastToUInt16TheoryData = new(_castToUInt16Data);
-		public static CastingTheoryData<Octo, uint> CastToUInt32TheoryData = new(_castToUInt32Data);
-		public static CastingTheoryData<Octo, ulong> CastToUInt64TheoryData = new(_castToUInt64Data);
-		public static CastingTheoryData<Octo, UInt128> CastToUInt128TheoryData = new(_castToUInt128Data);
-		public static CastingTheoryData<Octo, UInt256> CastToUInt256TheoryData = new(_castToUInt256Data);
-		public static CastingTheoryData<Octo, UInt512> CastToUInt512TheoryData = new(_castToUInt512Data);
-		public static CastingTheoryData<Octo, sbyte> CastToSByteTheoryData = new(_castToSByteData);
-		public static CastingTheoryData<Octo, short> CastToInt16TheoryData = new(_castToInt16Data);
-		public static CastingTheoryData<Octo, int> CastToInt32TheoryData = new(_castToInt32Data);
-		public static CastingTheoryData<Octo, long> CastToInt64TheoryData = new(_castToInt64Data);
-		public static CastingTheoryData<Octo, Int128> CastToInt128TheoryData = new(_castToInt128Data);
-		public static CastingTheoryData<Octo, Int256> CastToInt256TheoryData = new(_castToInt256Data);
-		public static CastingTheoryData<Octo, Int512> CastToInt512TheoryData = new(_castToInt512Data);
-		public static CastingTheoryData<Octo, Half> CastToHalfTheoryData = new(_castToHalfData);
-		public static CastingTheoryData<Octo, float> CastToSingleTheoryData = new(_castToSingleData);
-		public static CastingTheoryData<Octo, double> CastToDoubleTheoryData = new(_castToDoubleData);
-		public static CastingTheoryData<Octo, Quad> CastToQuadTheoryData = new(_castToQuadData);
-
-		public static RoundTheoryData<Octo> RoundAwayFromZeroTheoryData = new(_roundAwayFromZeroData);
-		public static RoundTheoryData<Octo> RoundToEvenTheoryData = new(_roundToEvenData);
-		public static RoundTheoryData<Octo> RoundToNegativeInfinityTheoryData = new(_roundToNegativeInfinityData);
-		public static RoundTheoryData<Octo> RoundToPositiveInfinityTheoryData = new(_roundToPositiveInfinityData);
-		public static RoundTheoryData<Octo> RoundToZeroTheoryData = new(_roundToZeroData);
-
-		public static FusedMultiplyAddTheoryData<Octo> FMATheoryData = new(_fmaData);
-#pragma warning restore S3263 // Static fields should appear in the order they must be initialized 
-	}
-}
diff --git a/src/MissingValues.Tests/Core/OctoTest.cs b/src/MissingValues.Tests/Core/OctoTest.cs
deleted file mode 100644
index 5002b14..0000000
--- a/src/MissingValues.Tests/Core/OctoTest.cs
+++ /dev/null
@@ -1,355 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class OctoTest
-    {
-		public static readonly Octo NegativeThousand = Values.CreateFloat<Octo>(0xC000_8F40_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeHundred = Values.CreateFloat<Octo>(0xC000_5900_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeTen = Values.CreateFloat<Octo>(0xC000_2400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeFive = Values.CreateFloat<Octo>(0xC000_1400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeFour = Values.CreateFloat<Octo>(0xC000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeThree = Values.CreateFloat<Octo>(0xC000_0800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeTwo = Values.CreateFloat<Octo>(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeOne = Octo.NegativeOne;
-		public static readonly Octo NegativeHalf = Values.CreateFloat<Octo>(0xBFFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeQuarter = Values.CreateFloat<Octo>(0xBFFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo NegativeZero = Octo.NegativeZero;
-		public static readonly Octo Zero = Octo.Zero;
-		public static readonly Octo Quarter = Values.CreateFloat<Octo>(0x3FFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Half = Values.CreateFloat<Octo>(0x3FFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo One = Octo.One;
-		public static readonly Octo Two = Values.CreateFloat<Octo>(0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Three = Values.CreateFloat<Octo>(0x4000_0800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Four = Values.CreateFloat<Octo>(0x4000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Five = Values.CreateFloat<Octo>(0x4000_1400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Ten = Values.CreateFloat<Octo>(0x4000_2400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Hundred = Values.CreateFloat<Octo>(0x4000_5900_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Thousand = Values.CreateFloat<Octo>(0x4000_8F40_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Octo GreaterThanOneSmallest = Values.CreateFloat<Octo>(0x3FFF_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-		public static readonly Octo LessThanOneLargest = Values.CreateFloat<Octo>(0x3FFF_EFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		public static readonly Octo SmallestSubnormal = Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-		public static readonly Octo GreatestSubnormal = Values.CreateFloat<Octo>(0x0000_0FFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		public static readonly Octo MaxValue = Octo.MaxValue;
-		public static readonly Octo MinValue = Octo.MinValue;
-
-		public static readonly Octo ByteMaxValue = Values.CreateFloat<Octo>(0x4000_6FE0_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo UInt16MaxValue = Values.CreateFloat<Octo>(0x4000_EFFF_E000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo UInt32MaxValue = Values.CreateFloat<Octo>(0x4001_EFFF_FFFF_E000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo UInt64MaxValue = Values.CreateFloat<Octo>(0x4003_EFFF_FFFF_FFFF, 0xFFFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo UInt128MaxValue = Values.CreateFloat<Octo>(0x4007_EFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_E000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo TwoOver255 = Values.CreateFloat<Octo>(0x400F_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo TwoOver511 = Values.CreateFloat<Octo>(0x401F_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Octo SByteMaxValue = Values.CreateFloat<Octo>(0x4000_5FC0_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo SByteMinValue = Values.CreateFloat<Octo>(0xC000_6000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int16MaxValue = Values.CreateFloat<Octo>(0x4000_DFFF_C000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int16MinValue = Values.CreateFloat<Octo>(0xC000_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int32MaxValue = Values.CreateFloat<Octo>(0x4001_DFFF_FFFF_C000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int32MinValue = Values.CreateFloat<Octo>(0xC001_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int64MaxValue = Values.CreateFloat<Octo>(0x4003_DFFF_FFFF_FFFF, 0xFFFF_C000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int64MinValue = Values.CreateFloat<Octo>(0xC003_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int128MaxValue = Values.CreateFloat<Octo>(0x4007_DFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_C000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Octo Int128MinValue = Values.CreateFloat<Octo>(0xC007_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Octo Delta = Values.CreateFloat<Octo>(0x400E_B000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly int Radix = 2;
-
-		[Fact]
-		public void Ctor_Empty()
-		{
-			var i = new Octo();
-			Assert.Equal(Zero, i);
-		}
-
-		[Theory]
-		[MemberData(nameof(CastFromByteTheoryData))]
-		public void Cast_FromByte(byte from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt16TheoryData))]
-		public void Cast_FromUInt16(ushort from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt32TheoryData))]
-		public void Cast_FromUInt32(uint from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt64TheoryData))]
-		public void Cast_FromUInt64(ulong from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt128TheoryData))]
-		public void Cast_FromUInt128(UInt128 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt256TheoryData))]
-		public void Cast_FromUInt256(UInt256 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt512TheoryData))]
-		public void Cast_FromUInt512(UInt512 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromSByteTheoryData))]
-		public void Cast_FromSByte(sbyte from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt16TheoryData))]
-		public void Cast_FromInt16(short from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt32TheoryData))]
-		public void Cast_FromInt32(int from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt64TheoryData))]
-		public void Cast_FromInt64(long from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt128TheoryData))]
-		public void Cast_FromInt128(Int128 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt256TheoryData))]
-		public void Cast_FromInt256(Int256 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt512TheoryData))]
-		public void Cast_FromInt512(Int512 from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Fact]
-		public void Cast_FromBigInteger()
-		{
-			TwoOver255.Should()
-				.Be((Octo)BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			TwoOver511
-				.Should()
-				.Be((Octo)BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-		}
-		[Theory]
-		[MemberData(nameof(CastFromHalfTheoryData))]
-		public void Cast_FromHalf(Half from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromSingleTheoryData))]
-		public void Cast_FromSingle(float from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromDoubleTheoryData))]
-		public void Cast_FromDouble(double from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-
-		[Theory]
-		[MemberData(nameof(CastToByteTheoryData))]
-		public void Cast_ToByte(Octo from, byte to)
-		{
-			((byte)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt16TheoryData))]
-		public void Cast_ToUInt16(Octo from, ushort to)
-		{
-			((ushort)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt32TheoryData))]
-		public void Cast_ToUInt32(Octo from, uint to)
-		{
-			((uint)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt64TheoryData))]
-		public void Cast_ToUInt64(Octo from, ulong to)
-		{
-			((ulong)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt128TheoryData))]
-		public void Cast_ToUInt128(Octo from, UInt128 to)
-		{
-			((UInt128)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt256TheoryData))]
-		public void Cast_ToUInt256(Octo from, UInt256 to)
-		{
-			((UInt256)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt512TheoryData))]
-		public void Cast_ToUInt512(Octo from, UInt512 to)
-		{
-			((UInt512)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToSByteTheoryData))]
-		public void Cast_ToSByte(Octo from, sbyte to)
-		{
-			((sbyte)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt16TheoryData))]
-		public void Cast_ToInt16(Octo from, short to)
-		{
-			((short)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt32TheoryData))]
-		public void Cast_ToInt32(Octo from, int to)
-		{
-			((int)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt64TheoryData))]
-		public void Cast_ToInt64(Octo from, long to)
-		{
-			((long)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt128TheoryData))]
-		public void Cast_ToInt128(Octo from, Int128 to)
-		{
-			((Int128)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt256TheoryData))]
-		public void Cast_ToInt256(Octo from, Int256 to)
-		{
-			((Int256)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt512TheoryData))]
-		public void Cast_ToInt512(Octo from, Int512 to)
-		{
-			((Int512)from).Should().Be(to);
-		}
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968")
-				.Should().Be((BigInteger)TwoOver255);
-			BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048")
-				.Should().Be((BigInteger)TwoOver511);
-		}
-		[Theory]
-		[MemberData(nameof(CastToHalfTheoryData))]
-		public void Cast_ToHalf(Octo from, Half to)
-		{
-			((Half)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToSingleTheoryData))]
-		public void Cast_ToSingle(Octo from, float to)
-		{
-			((float)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToDoubleTheoryData))]
-		public void Cast_ToDouble(Octo from, double to)
-		{
-			((double)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToQuadTheoryData))]
-		public void Cast_ToQuad(Octo from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-
-		[Fact]
-		public void ToGeneralStringTest()
-		{
-			Zero.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("0");
-			One.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("1");
-			Two.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("2");
-			Three.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("3");
-			Five.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("5");
-			Ten.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("10");
-			Hundred.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("100");
-			Thousand.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("1000");
-			(new Octo(0x400E_ACFA_698C_9539, 0x0BA8_8C1B_7795_0E32, 0xD6C2_C314_97A4_2D00, 0x0000_0000_0000_0000)) // 1E71
-				.ToString("G70", CultureInfo.InvariantCulture)
-				.Should().Be("1E+71");
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void BasicTryParseTest(string s, bool success, Octo expected)
-		{
-			Octo.TryParse(s, out Octo actual).Should().Be(success);
-			actual.Should().Be(expected);
-		}
-
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new Octo[] { MaxValue, One, Half, Quarter, Zero })
-				.Should().Be($"[{MaxValue.ToString(null, CultureInfo.InvariantCulture)},1,0.5,0.25,0]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			string toString = Quarter.ToString(null, CultureInfo.InvariantCulture);
-
-			JsonSerializer.Deserialize<Octo>(toString)
-				.Should().Be(Quarter);
-			JsonSerializer.Deserialize<Octo>(Encoding.UTF8.GetBytes(toString))
-				.Should().Be(Quarter);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/QuadTest.GenericMath.cs b/src/MissingValues.Tests/Core/QuadTest.GenericMath.cs
deleted file mode 100644
index cc86743..0000000
--- a/src/MissingValues.Tests/Core/QuadTest.GenericMath.cs
+++ /dev/null
@@ -1,1466 +0,0 @@
-using MissingValues.Tests.Helpers;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-
-using Float = MissingValues.Quad;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class QuadTest
-	{
-		#region Generic Math Operators
-		[Theory]
-		[MemberData(nameof(UnaryNegationOperationTheoryData))]
-		public static void op_UnaryNegationTest(Float self, Float result)
-		{
-			MathOperatorsHelper.UnaryNegationOperation<Float, Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(AdditionOperationTheoryData))]
-		public static void op_AdditionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.AdditionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(IncrementOperationTheoryData))]
-		public static void op_IncrementTest(Float self, Float result)
-		{
-			MathOperatorsHelper.IncrementOperation<Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(SubtractionOperationTheoryData))]
-		public static void op_SubtractionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.SubtractionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(DecrementOperationTheoryData))]
-		public static void op_DecrementTest(Float self, Float result)
-		{
-			MathOperatorsHelper.DecrementOperation<Float>(self)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(MultiplicationOperationTheoryData))]
-		public static void op_MultiplicationTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.MultiplicationOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Theory]
-		[MemberData(nameof(DivisionOperationTheoryData))]
-		public static void op_DivisionTest(Float left, Float right, Float result)
-		{
-			MathOperatorsHelper.DivisionOperation<Float, Float, Float>(left, right)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Fact]
-		public static void op_BitwiseAndTest()
-		{
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseAndOperation(Zero, Values.CreateFloat<Float>(0x0, 0x1)).Should().Be(Zero);
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseAndOperation(Values.CreateFloat<Float>(0x0, 0x1), Values.CreateFloat<Float>(0x0, 0x1)).Should().Be(Values.CreateFloat<Float>(0x0, 0x1));
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseAndOperation(BinaryNumberHelper<Float>.AllBitsSet, Values.CreateFloat<Float>(0x0, 0x1)).Should().Be(Values.CreateFloat<Float>(0x0, 0x1));
-		}
-		[Fact]
-		public static void op_BitwiseOrTest()
-		{
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseOrOperation(Zero, Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Values.CreateFloat<Float>(0x0, 0x1));
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseOrOperation(Values.CreateFloat<Float>(0x0, 0x1), Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Values.CreateFloat<Float>(0x0, 0x1));
-			BitwiseOperatorsHelper<Float, Float, Float>.BitwiseOrOperation(BinaryNumberHelper<Float>.AllBitsSet, Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(BinaryNumberHelper<Float>.AllBitsSet);
-		}
-		[Fact]
-		public static void op_ExclusiveOrTest()
-		{
-			BitwiseOperatorsHelper<Float, Float, Float>.ExclusiveOrOperation(Zero, Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Values.CreateFloat<Float>(0x0, 0x1));
-			BitwiseOperatorsHelper<Float, Float, Float>.ExclusiveOrOperation(Values.CreateFloat<Float>(0x0, 0x1), Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Zero);
-			BitwiseOperatorsHelper<Float, Float, Float>.ExclusiveOrOperation(BinaryNumberHelper<Float>.AllBitsSet, Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Values.CreateFloat<Float>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		}
-		[Fact]
-		public static void op_OnesComplementTest()
-		{
-			BitwiseOperatorsHelper<Float, Float, Float>.OnesComplementOperation(Zero)
-				.Should().Be(BinaryNumberHelper<Float>.AllBitsSet);
-			BitwiseOperatorsHelper<Float, Float, Float>.OnesComplementOperation(Values.CreateFloat<Float>(0x0, 0x1))
-				.Should().Be(Values.CreateFloat<Float>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-			BitwiseOperatorsHelper<Float, Float, Float>.OnesComplementOperation(BinaryNumberHelper<Float>.AllBitsSet)
-				.Should().Be(Zero);
-		}
-		[Theory]
-		[MemberData(nameof(GreaterThanTheoryData))]
-		public static void op_GreaterThanTest(Float left, Float right, bool result)
-		{
-			ComparisonOperatorsHelper<Float, Float, bool>.GreaterThanOperation(left, right)
-				.Should().Be(result);
-		}
-		[Theory]
-		[MemberData(nameof(GreaterThanTheoryData))]
-		[MemberData(nameof(EqualToTheoryData))]
-		public static void op_GreaterThanOrEqualTest(Float left, Float right, bool result)
-		{
-			ComparisonOperatorsHelper<Float, Float, bool>.GreaterThanOrEqualOperation(left, right)
-				.Should().Be(result);
-		}
-		[Theory]
-		[MemberData(nameof(LessThanTheoryData))]
-		public static void op_LessThanTest(Float left, Float right, bool result)
-		{
-			ComparisonOperatorsHelper<Float, Float, bool>.LessThanOperation(left, right)
-				.Should().Be(result);
-		}
-		[Theory]
-		[MemberData(nameof(LessThanTheoryData))]
-		[MemberData(nameof(EqualToTheoryData))]
-		public static void op_LessThanOrEqualTest(Float left, Float right, bool result)
-		{
-			ComparisonOperatorsHelper<Float, Float, bool>.LessThanOrEqualOperation(left, right)
-				.Should().Be(result);
-		}
-		[Theory]
-		[MemberData(nameof(EqualToTheoryData))]
-		public static void op_EqualToTest(Float left, Float right, bool result)
-		{
-			EqualityOperatorsHelper<Float, Float, bool>.EqualityOperation(left, right)
-				.Should().Be(result);
-		}
-		[Theory]
-		[MemberData(nameof(NotEqualToTheoryData))]
-		public static void op_NotEqualToTest(Float left, Float right, bool result)
-		{
-			EqualityOperatorsHelper<Float, Float, bool>.InequalityOperation(left, right)
-				.Should().Be(result);
-		}
-		#endregion
-
-		#region Identities
-		[Fact]
-		public static void AdditiveIdentityTest()
-		{
-			Assert.Equal(Zero, MathConstantsHelper.AdditiveIdentityHelper<Float, Float>());
-		}
-
-		[Fact]
-		public static void MultiplicativeIdentityTest()
-		{
-			Assert.Equal(One, MathConstantsHelper.MultiplicativeIdentityHelper<Float, Float>());
-		}
-		#endregion
-
-		#region IBinaryFloatingPointIEEE
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			BinaryNumberHelper<Float>.AllBitsSet.Should().Be(BitwiseOperatorsHelper<Float, Float, Float>.OnesComplementOperation(Zero));
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			BinaryNumberHelper<Float>.IsPow2(Half).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(One).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(Two).Should().BeTrue();
-			BinaryNumberHelper<Float>.IsPow2(Three).Should().BeFalse();
-			BinaryNumberHelper<Float>.IsPow2(NegativeTwo).Should().BeFalse();
-		}
-		#endregion
-
-		#region IFloatingPointIEEE
-		[Fact]
-		public static void EpsilonTest()
-		{
-			FloatingPointIeee754<Float>.Epsilon.Should().Be(Float.Epsilon);
-			MathOperatorsHelper.AdditionOperation<Float, Float, Float>(FloatingPointIeee754<Float>.Epsilon, NumberBaseHelper<Float>.Zero)
-				.Should().NotBe(Float.Zero);
-		}
-		[Fact]
-		public static void NaNTest()
-		{
-			FloatingPointIeee754<Float>.NaN
-				.Should().Be(Float.NaN)
-				.And.BeNaN();
-			NumberBaseHelper<Float>.IsNaN(FloatingPointIeee754<Float>.NaN).Should().BeTrue();
-		}
-		[Fact]
-		public static void NegativeInfinityTest()
-		{
-			FloatingPointIeee754<Float>.NegativeInfinity.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.IsInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegativeInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositiveInfinity(FloatingPointIeee754<Float>.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void PositiveInfinityTest()
-		{
-			FloatingPointIeee754<Float>.PositiveInfinity.Should().Be(Float.PositiveInfinity);
-			NumberBaseHelper<Float>.IsInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegativeInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(FloatingPointIeee754<Float>.PositiveInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void AcosTest()
-		{
-			GenericFloatingPointFunctions.Acos<Float>(Float.NaN)
-				.Should()
-				.BeBitwiseEquivalentTo(Float.NaN)
-				.And.BeNaN();
-			GenericFloatingPointFunctions.Acos<Float>(Two)
-				.Should().BeNaN();
-			GenericFloatingPointFunctions.Acos<Float>(NegativeTwo)
-				.Should().BeNaN();
-			GenericFloatingPointFunctions.Acos<Float>(Half)
-				.Should().BeApproximately(Float.Pi / 3, Delta);
-			GenericFloatingPointFunctions.Acos<Float>(One)
-				.Should().BeApproximately(Float.Zero, Delta);
-			GenericFloatingPointFunctions.Acos<Float>(NegativeOne)
-				.Should().BeApproximately(Float.Pi, Delta);
-		}
-		[Fact]
-		public static void AcoshTest()
-		{
-			GenericFloatingPointFunctions.Acosh<Float>(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFF_5124_2719_8043, 0x49BE_684B_D018_8D53), Delta);
-			GenericFloatingPointFunctions.Acosh<Float>(Half)
-				.Should().BeNaN();
-			GenericFloatingPointFunctions.Acosh<Float>(Zero)
-				.Should().BeNaN();
-			GenericFloatingPointFunctions.Acosh<Float>(NegativeOne)
-				.Should().BeNaN();
-		}
-		[Fact]
-		public static void AsinTest()
-		{
-			GenericFloatingPointFunctions.Asin<Float>(Half)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFE_0C15_2382_D736, 0x5846_5BB3_2E0F_567B), Delta)
-				.And.BeApproximately(Float.Pi / Six, Delta);
-			GenericFloatingPointFunctions.Asin<Float>(Two)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Asin<Float>(One)
-				.Should().BeApproximately(Float.Pi / Two, Delta);
-			GenericFloatingPointFunctions.Asin<Float>(NegativeOne)
-				.Should().BeApproximately(-Float.Pi / Two, Delta);
-		}
-		[Fact]
-		public static void AsinhTest()
-		{
-			GenericFloatingPointFunctions.Asinh<Float>(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFF_7192_1831_3D08, 0x72F8_E831_837F_0E95), Delta);
-			GenericFloatingPointFunctions.Asinh<Float>(Zero)
-				.Should().BeApproximately(Zero, Delta);
-			GenericFloatingPointFunctions.Asinh<Float>(Values.CreateFloat<Float>(0xBFFF_8000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFF_31DC_0090_B63D, 0x8682_7E4B_AAAD_1909), Delta);
-		}
-		[Fact]
-		public static void AtanTest()
-		{
-			GenericFloatingPointFunctions.Atan<Float>(Half)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Delta);
-			GenericFloatingPointFunctions.Atan<Float>(Zero)
-				.Should().BeApproximately(Zero, Delta);
-			GenericFloatingPointFunctions.Atan<Float>(Float.PositiveInfinity)
-				.Should().BeApproximately(Float.Pi / Two, Delta);
-			GenericFloatingPointFunctions.Atan<Float>(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFF_1B6E_192E_BBE4, 0x3F5A_7D44_566B_01A8), Delta);
-		}
-		[Fact]
-		public static void Atan2Test()
-		{
-			FloatingPointIeee754<Float>.Atan2(Zero, Two)
-				.Should().BeApproximately(Zero, Delta);
-			FloatingPointIeee754<Float>.Atan2(Zero, Zero)
-				.Should().BeApproximately(Zero, Delta);
-			FloatingPointIeee754<Float>.Atan2(Zero, NegativeTwo)
-				.Should().BeApproximately(Float.Pi, Delta);
-			FloatingPointIeee754<Float>.Atan2(One, Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Delta);
-			FloatingPointIeee754<Float>.Atan2(NegativeOne, Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0xBFFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Delta);
-			FloatingPointIeee754<Float>.Atan2(One, NegativeTwo)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4000_56C6_E739_7F5A, 0xE130_A2BB_E272_574C), Delta);
-		}
-		[Fact]
-		public static void AtanhTest()
-		{
-			GenericFloatingPointFunctions.Atanh<Float>(Two)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Atanh<Float>(NegativeFour)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Atanh<Float>(Zero)
-				.Should().BeApproximately(Zero, Delta);
-			GenericFloatingPointFunctions.Atanh<Float>(Half)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFE_193E_A7AA_D030, 0xA976_BA8D_B53A_D6E3), Delta);
-		}
-		[Fact]
-		public static void BitDecrementTest()
-		{
-			FloatingPointIeee754<Float>.BitDecrement(One)
-				.Should().Be(Values.CreateFloat<Float>(0x3FFEFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
-			FloatingPointIeee754<Float>.BitDecrement(NegativeOne)
-				.Should().Be(Values.CreateFloat<Float>(0xBFFF000000000000, 0x0000000000000001));
-			FloatingPointIeee754<Float>.BitDecrement(Zero)
-				.Should().Be(-Float.Epsilon);
-			FloatingPointIeee754<Float>.BitDecrement(Float.NegativeInfinity)
-				.Should().Be(Float.NegativeInfinity);
-			FloatingPointIeee754<Float>.BitDecrement(Float.PositiveInfinity)
-				.Should().Be(Float.MaxValue);
-		}
-		[Fact]
-		public static void BitIncrementTest()
-		{
-			FloatingPointIeee754<Float>.BitIncrement(One)
-				.Should().Be(Values.CreateFloat<Float>(0x3FFF000000000000, 0x0000000000000001));
-			FloatingPointIeee754<Float>.BitIncrement(NegativeOne)
-				.Should().Be(Values.CreateFloat<Float>(0xBFFEFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
-			FloatingPointIeee754<Float>.BitIncrement(NegativeZero)
-				.Should().Be(Float.Epsilon);
-			FloatingPointIeee754<Float>.BitIncrement(Float.NegativeInfinity)
-				.Should().Be(Float.MinValue);
-			FloatingPointIeee754<Float>.BitIncrement(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void CbrtTest()
-		{
-			GenericFloatingPointFunctions.Cbrt(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(Four);
-
-
-			GenericFloatingPointFunctions.Cbrt(Zero)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Cbrt(-Zero)
-				.Should().Be(-Zero);
-			GenericFloatingPointFunctions.Cbrt(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Cbrt(NegativeFour)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0xBFFF_965F_EA53_D6E3, 0xC82B_0599_9AB4_3DC5), Delta);
-			GenericFloatingPointFunctions.Cbrt(Float.NaN)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void CosTest()
-		{
-			GenericFloatingPointFunctions.Cos(Zero)
-				.Should().BeApproximately(One, Delta);
-			GenericFloatingPointFunctions.Cos(Float.Pi / Two)
-				.Should().BeApproximately(Zero, Delta);
-			GenericFloatingPointFunctions.Cos(Float.Pi)
-				.Should().BeApproximately(NegativeOne, Delta);
-			GenericFloatingPointFunctions.Cos(Float.Pi * Two)
-				.Should().BeApproximately(One, Delta);
-
-			GenericFloatingPointFunctions.Cos(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Cos(Float.PositiveInfinity)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Cos(Float.NegativeInfinity)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void CoshTest()
-		{
-			GenericFloatingPointFunctions.Cosh(Zero)
-				.Should().Be(One);
-			GenericFloatingPointFunctions.Cosh(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4000_E18F_A0DF_2D9B, 0xC293_27F7_1777_4D0C), Delta);
-			GenericFloatingPointFunctions.Cosh(Five)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4005_28D6_FCBE_FF3A, 0x9C65_3333_916C_7D52), Delta);
-			GenericFloatingPointFunctions.Cosh(NegativeFive)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4005_28D6_FCBE_FF3A, 0x9C65_3333_916C_7D52), Delta);
-		}
-		[Fact]
-		public static void ExpTest()
-		{
-			GenericFloatingPointFunctions.Exp(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4001_D8E6_4B8D_4DDA, 0xDCC3_3A3B_A206_B68B), Delta);
-			GenericFloatingPointFunctions.Exp(NegativeHalf)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFE_368B_2FC6_F960, 0x9FE7_ACEB_46AA_619C), Delta);
-			GenericFloatingPointFunctions.Exp(Values.CreateFloat<Float>(0x400C_7700_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Exp(Values.CreateFloat<Float>(0xC00C_7700_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Exp(Zero)
-				.Should().Be(One);
-			GenericFloatingPointFunctions.Exp(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Exp(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Exp(Float.NegativeInfinity)
-				.Should().Be(Zero);
-		}
-		[Fact]
-		public static void ExpM1Test()
-		{
-			GenericFloatingPointFunctions.ExpM1(Two)
-				.Should().BeApproximately(GenericFloatingPointFunctions.Exp(Two) - One, Delta);
-			GenericFloatingPointFunctions.ExpM1(NegativeHalf)
-				.Should().BeApproximately(GenericFloatingPointFunctions.Exp(NegativeHalf) - One, Delta);
-		}
-		[Fact]
-		public static void Exp10Test()
-		{
-			GenericFloatingPointFunctions.Exp10(Two)
-				.Should().Be(Hundred);
-			GenericFloatingPointFunctions.Exp10(Zero)
-				.Should().Be(One);
-			GenericFloatingPointFunctions.Exp10(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Exp10(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Exp10(Float.NegativeInfinity)
-				.Should().Be(Zero);
-		}
-		[Fact]
-		public static void Exp2Test()
-		{
-			GenericFloatingPointFunctions.Exp2(Two)
-				.Should().Be(Four);
-			GenericFloatingPointFunctions.Exp2(Zero)
-				.Should().Be(One);
-			GenericFloatingPointFunctions.Exp2(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Exp2(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Exp2(Float.NegativeInfinity)
-				.Should().Be(Zero);
-		}
-		[Theory]
-		[MemberData(nameof(FMATheoryData))]
-		public static void FusedMultiplyAddTest(Float left, Float right, Float addend, Float result)
-		{
-			FloatingPointIeee754<Float>.FusedMultiplyAdd(left, right, addend)
-				.Should().Be(result)
-				.And.BeBitwiseEquivalentTo(result);
-		}
-		[Fact]
-		public static void HypotTest()
-		{
-			GenericFloatingPointFunctions.Hypot(Hundred, Ten)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4005_91FE_B9F2_BF46, 0xC3A7_08A3_1212_49E7), Delta);
-			GenericFloatingPointFunctions.Hypot(Float.PositiveInfinity, Float.NegativeInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Hypot(Float.NaN, Float.NaN)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void IeeeRemainderTest()
-		{
-			FloatingPointIeee754<Float>.Ieee754Remainder(Ten, Three).Should().Be(One);
-			FloatingPointIeee754<Float>.Ieee754Remainder(Ten, Two).Should().Be(Zero);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Three).Should().Be(NegativeOne);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Two).Should().Be(NegativeZero);
-			FloatingPointIeee754<Float>.Ieee754Remainder(NegativeTen, Zero).Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void ILogBTest()
-		{
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0x4009_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(10);
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0x403F_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(64);
-			FloatingPointIeee754<Float>.ILogB(Values.CreateFloat<Float>(0xC03F_0000_0000_0000, 0x0000_0000_0000_0000))
-				.Should().Be(64);
-			FloatingPointIeee754<Float>.ILogB(Zero)
-				.Should().Be(int.MinValue);
-		}
-		[Fact]
-		public static void LogTest()
-		{
-			GenericFloatingPointFunctions.Log(Hundred)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4001_26BB_1BBB_5551, 0x582D_D4AD_AC57_05A6), Delta);
-			GenericFloatingPointFunctions.Log(One)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Log(Zero)
-				.Should().Be(Float.NegativeInfinity);
-			GenericFloatingPointFunctions.Log(NegativeFive)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void LogP1Test()
-		{
-			GenericFloatingPointFunctions.LogP1(One)
-				.Should().Be(GenericFloatingPointFunctions.Log(Two))
-				.And.BeApproximately(Values.CreateFloat<Float>(0x3FFE_62E4_2FEF_A39E, 0xF357_93C7_6730_07E6), Delta);
-			GenericFloatingPointFunctions.LogP1(Zero)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.LogP1(NegativeOne)
-				.Should().Be(Float.NegativeInfinity);
-			GenericFloatingPointFunctions.LogP1(NegativeFive)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void Log2Test()
-		{
-			GenericFloatingPointFunctions.Log2(Four)
-				.Should().BeApproximately(Two, Delta);
-			GenericFloatingPointFunctions.Log2(One)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Log2(Zero)
-				.Should().Be(Float.NegativeInfinity);
-			GenericFloatingPointFunctions.Log2(NegativeFive)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void Log10Test()
-		{
-			GenericFloatingPointFunctions.Log10(Thousand)
-				.Should().BeApproximately(Three, Delta);
-			GenericFloatingPointFunctions.Log10(One)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Log10(Zero)
-				.Should().Be(Float.NegativeInfinity);
-			GenericFloatingPointFunctions.Log10(NegativeFive)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void PowTest()
-		{
-			GenericFloatingPointFunctions.Pow<Float>(Three, Ten)
-				.Should()
-				.BeApproximately(Values.CreateFloat<Float>(0x400E_CD52_0000_0000, 0x0000_0000_0000_0000), Delta);
-			GenericFloatingPointFunctions.Pow<Float>(Two, NegativeFour)
-				.Should()
-				.BeApproximately(Values.CreateFloat<Float>(0x3FFB_0000_0000_0000, 0x0000_0000_0000_0000), Delta);
-
-			// Special Cases
-			Float anything = 8, oddInt = 7, nonInt = 7.5d, greaterThanOne = GreaterThanOneSmallest, lessThanOne = LessThanOneLargest;
-
-			GenericFloatingPointFunctions.Pow<Float>(anything, Zero)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(anything, One)
-				.Should()
-				.Be(anything);
-
-			GenericFloatingPointFunctions.Pow<Float>(anything, Float.NaN)
-				.Should()
-				.Be(Float.NaN);
-
-			GenericFloatingPointFunctions.Pow<Float>(One, Float.NaN)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(Float.NaN, anything)
-				.Should()
-				.Be(Float.NaN);
-
-			GenericFloatingPointFunctions.Pow<Float>(greaterThanOne, Float.PositiveInfinity)
-				.Should()
-				.Be(Float.PositiveInfinity);
-
-			GenericFloatingPointFunctions.Pow<Float>(greaterThanOne, Float.NegativeInfinity)
-				.Should()
-				.Be(Zero);
-
-			GenericFloatingPointFunctions.Pow<Float>(lessThanOne, Float.PositiveInfinity)
-				.Should()
-				.Be(Zero);
-
-			GenericFloatingPointFunctions.Pow<Float>(lessThanOne, Float.NegativeInfinity)
-				.Should()
-				.Be(Float.PositiveInfinity);
-
-			GenericFloatingPointFunctions.Pow<Float>(One, Float.PositiveInfinity)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(One, Float.NegativeInfinity)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(NegativeOne, Float.PositiveInfinity)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(NegativeOne, Float.NegativeInfinity)
-				.Should()
-				.Be(One);
-
-			GenericFloatingPointFunctions.Pow<Float>(Zero, anything)
-				.Should()
-				.Be(Zero);
-
-			GenericFloatingPointFunctions.Pow<Float>(NegativeZero, anything)
-				.Should()
-				.Be(Zero);
-
-			GenericFloatingPointFunctions.Pow<Float>(Zero, -anything)
-				.Should()
-				.Be(Float.PositiveInfinity);
-
-			GenericFloatingPointFunctions.Pow<Float>(NegativeZero, -anything)
-				.Should()
-				.Be(Float.PositiveInfinity);
-
-			GenericFloatingPointFunctions.Pow<Float>(NegativeZero, oddInt)
-				.Should()
-				.Be(-(GenericFloatingPointFunctions.Pow<Float>(Zero, oddInt)));
-
-			GenericFloatingPointFunctions.Pow<Float>(Float.PositiveInfinity, anything)
-				.Should()
-				.Be(Float.PositiveInfinity);
-
-			GenericFloatingPointFunctions.Pow<Float>(Float.PositiveInfinity, -anything)
-				.Should()
-				.Be(Zero);
-
-			GenericFloatingPointFunctions.Pow<Float>(Float.NegativeInfinity, anything)
-				.Should()
-				.Be(GenericFloatingPointFunctions.Pow<Float>(NegativeZero, -anything));
-			
-			GenericFloatingPointFunctions.Pow<Float>(-anything, oddInt)
-				.Should()
-				.Be(GenericFloatingPointFunctions.Pow<Float>(NegativeOne, oddInt) * GenericFloatingPointFunctions.Pow<Float>(+anything, oddInt));
-
-			GenericFloatingPointFunctions.Pow<Float>(-anything, nonInt)
-				.Should()
-				.Be(Float.NaN);
-		}
-		[Fact]
-		public static void ReciprocalEstimateTest()
-		{
-			FloatingPointIeee754<Float>.ReciprocalEstimate(Two)
-				.Should().Be(Half);
-			FloatingPointIeee754<Float>.ReciprocalEstimate(Three)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFD_5555_5555_5555, 0x5555_165E_5289_24A5), Delta);
-			FloatingPointIeee754<Float>.ReciprocalEstimate(Four)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFD_0000_0000_0000, 0x0000_0000_0000_0000), Delta);
-		}
-		[Fact]
-		public static void RootNTest()
-		{
-			GenericFloatingPointFunctions.RootN(Values.CreateFloat<Float>(0x4005_4400_0000_0000, 0x0000_0000_0000_0000), 4)
-				.Should().Be(Three);
-			GenericFloatingPointFunctions.RootN(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000), 3)
-				.Should().Be(Four)
-				.And.Be(GenericFloatingPointFunctions.Cbrt(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000)));
-			GenericFloatingPointFunctions.RootN(Hundred, 2)
-				.Should().Be(Ten)
-				.And.Be(GenericFloatingPointFunctions.Sqrt(Hundred));
-
-			GenericFloatingPointFunctions.RootN(Zero, 2)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.RootN(NegativeZero, 2)
-				.Should().Be(NegativeZero);
-			GenericFloatingPointFunctions.RootN(Float.PositiveInfinity, 2)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.RootN(NegativeFour, 2)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.RootN(Float.NaN, 2)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void ScaleBTest()
-		{
-			FloatingPointIeee754<Float>.ScaleB(Two, 3)
-				.Should().Be(Values.CreateFloat<Float>(0x4003_0000_0000_0000, 0x0000_0000_0000_0000));
-			FloatingPointIeee754<Float>.ScaleB(NegativeTwo, 3)
-				.Should().Be(Values.CreateFloat<Float>(0xC003_0000_0000_0000, 0x0000_0000_0000_0000));
-			FloatingPointIeee754<Float>.ScaleB(Zero, 6)
-				.Should().Be(Zero);
-			FloatingPointIeee754<Float>.ScaleB(Two, 30000)
-				.Should().Be(Float.PositiveInfinity);
-			FloatingPointIeee754<Float>.ScaleB(Two, -30000)
-				.Should().Be(Zero);
-		}
-		[Fact]
-		public static void SinTest()
-		{
-			GenericFloatingPointFunctions.Sin(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Sin(Float.PositiveInfinity)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Sin(Float.NegativeInfinity)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void SinCosTest()
-		{
-			Float sin, cos;
-
-			(sin, cos) = GenericFloatingPointFunctions.SinCos(Zero);
-			sin.Should().BeApproximately(Zero, Delta);
-			cos.Should().BeApproximately(One, Delta);
-
-			(sin, cos) = GenericFloatingPointFunctions.SinCos(Float.Pi);
-			sin.Should().BeApproximately(Zero, Delta);
-			cos.Should().BeApproximately(NegativeOne, Delta);
-			
-			(sin, cos) = GenericFloatingPointFunctions.SinCos(Float.Pi / Two);
-			sin.Should().BeApproximately(One, Delta);
-			cos.Should().BeApproximately(Zero, Delta);
-
-			(sin, cos) = GenericFloatingPointFunctions.SinCos(Float.Pi * Two);
-			sin.Should().BeApproximately(Zero, Delta);
-			cos.Should().BeApproximately(One, Delta);
-		}
-		[Fact]
-		public static void SinhTest()
-		{
-			GenericFloatingPointFunctions.Sinh(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4000_D03C_F63B_6E19, 0xF6F3_4C80_2C96_2009), Delta);
-			GenericFloatingPointFunctions.Sinh(Zero)
-				.Should().Be(Zero);
-		}
-		[Fact]
-		public static void SqrtTest()
-		{
-			GenericFloatingPointFunctions.Sqrt(Ten)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x4000_94C5_83AD_A5B5, 0x2920_4A2B_C830_CD9C), Delta);
-			GenericFloatingPointFunctions.Sqrt(Hundred)
-				.Should().BeApproximately(Ten, Delta);
-
-			GenericFloatingPointFunctions.Sqrt(Zero)
-				.Should().Be(Zero);
-			GenericFloatingPointFunctions.Sqrt(-Zero)
-				.Should().Be(-Zero);
-			GenericFloatingPointFunctions.Sqrt(Float.PositiveInfinity)
-				.Should().Be(Float.PositiveInfinity);
-			GenericFloatingPointFunctions.Sqrt(NegativeFour)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Sqrt(Float.NaN)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void TanTest()
-		{
-			GenericFloatingPointFunctions.Tan(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Tan(Float.PositiveInfinity)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Tan(Float.NegativeInfinity)
-				.Should().Be(Float.NaN);
-		}
-		[Fact]
-		public static void TanhTest()
-		{
-			GenericFloatingPointFunctions.Tanh(Two)
-				.Should().BeApproximately(Values.CreateFloat<Float>(0x3FFE_ED95_05E1_BC3D, 0x3D33_C432_FC3E_8256), Delta);
-			GenericFloatingPointFunctions.Tanh(Float.NaN)
-				.Should().Be(Float.NaN);
-			GenericFloatingPointFunctions.Tanh(Zero)
-				.Should().Be(Zero);
-		}
-		#endregion
-
-		#region IFloatingPoint
-		[Theory]
-		[MemberData(nameof(RoundAwayFromZeroTheoryData))]
-		[MemberData(nameof(RoundToEvenTheoryData))]
-		[MemberData(nameof(RoundToNegativeInfinityTheoryData))]
-		[MemberData(nameof(RoundToPositiveInfinityTheoryData))]
-		[MemberData(nameof(RoundToZeroTheoryData))]
-		public static void RoundTest(Float self, int digits, MidpointRounding midpointRounding, Float result)
-		{
-			Float.Round(self, digits, midpointRounding).Should().Be(result);
-		}
-		#endregion
-
-		#region IFloatingPointConstants
-		[Fact]
-		public static void ConstantPiTest()
-		{
-			Assert.Equal(Float.Pi, MathConstantsHelper.Pi<Float>());
-		}
-		[Fact]
-		public static void ConstantTauTest()
-		{
-			Assert.Equal(Float.Tau, MathConstantsHelper.Tau<Float>());
-		}
-		[Fact]
-		public static void ConstantETest()
-		{
-			Assert.Equal(Float.E, MathConstantsHelper.E<Float>());
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<Float>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			MinValue.Should().Be(MathConstantsHelper.MinValue<Float>());
-		}
-		#endregion
-
-		#region ISignedNumber
-		[Fact]
-		public static void NegativeOneTest()
-		{
-			MathConstantsHelper.NegativeOne<Float>().Should().Be(NegativeOne);
-			MathConstantsHelper.NegativeOne<Float>().Should().Be(-One);
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<Float>.Clamp(Float.NegativeInfinity, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.MinValue, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(NegativeOne, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(-GreatestSubnormal, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(-Float.Epsilon, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(NegativeZero, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.NaN, One, Thousand)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Clamp(Zero, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.Epsilon, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(GreatestSubnormal, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(One, One, Thousand)
-				.Should().Be(One);
-			NumberHelper<Float>.Clamp(Float.MaxValue, One, Thousand)
-				.Should().Be(Thousand);
-			NumberHelper<Float>.Clamp(Float.PositiveInfinity, One, Thousand)
-				.Should().Be(Thousand);
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<Float>.CopySign(One, NegativeOne)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.CopySign(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.CopySign(Thousand, NegativeOne)
-				.Should().Be(NegativeThousand);
-			NumberHelper<Float>.CopySign(NegativeHundred, NegativeOne)
-				.Should().Be(NegativeHundred);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<Float>.Max(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.MinValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(NegativeZero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Max(Zero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Max(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberHelper<Float>.Max(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<Float>.MaxNumber(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.MinValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(NegativeOne, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(NegativeZero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Zero, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MaxNumber(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberHelper<Float>.MaxNumber(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<Float>.Min(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberHelper<Float>.Min(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberHelper<Float>.Min(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.Min(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberHelper<Float>.Min(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberHelper<Float>.Min(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberHelper<Float>.Min(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberHelper<Float>.Min(Zero, One)
-				.Should().Be(Zero);
-			NumberHelper<Float>.Min(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberHelper<Float>.Min(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberHelper<Float>.Min(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Min(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.Min(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<Float>.MinNumber(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberHelper<Float>.MinNumber(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberHelper<Float>.MinNumber(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberHelper<Float>.MinNumber(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberHelper<Float>.MinNumber(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberHelper<Float>.MinNumber(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberHelper<Float>.MinNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Zero, One)
-				.Should().Be(Zero);
-			NumberHelper<Float>.MinNumber(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberHelper<Float>.MinNumber(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberHelper<Float>.MinNumber(One, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberHelper<Float>.MinNumber(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<Float>.Sign(One)
-				.Should().Be(1);
-			NumberHelper<Float>.Sign(NegativeOne)
-				.Should().Be(-1);
-			NumberHelper<Float>.Sign(Ten)
-				.Should().Be(1);
-			NumberHelper<Float>.Sign(NegativeTen)
-				.Should().Be(-1);
-			NumberHelper<Float>.Sign(Zero)
-				.Should().Be(0);
-			NumberHelper<Float>.Sign(NegativeZero)
-				.Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void OneTest()
-		{
-			Assert.Equal(One, NumberBaseHelper<Float>.One);
-		}
-		[Fact]
-		public static void ZeroTest()
-		{
-			Assert.Equal(Zero, NumberBaseHelper<Float>.Zero);
-		}
-		[Fact]
-		public static void RadixTest()
-		{
-			Assert.Equal(Radix, NumberBaseHelper<Float>.Radix);
-		}
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<Float>.Abs(One).Should().Be(One);
-			NumberBaseHelper<Float>.Abs(NegativeOne).Should().Be(One);
-			NumberBaseHelper<Float>.Abs(NegativeHalf).Should().Be(Half);
-			NumberBaseHelper<Float>.Abs(NegativeQuarter).Should().Be(Quarter);
-			NumberBaseHelper<Float>.Abs(NegativeZero).Should().Be(Zero);
-			NumberBaseHelper<Float>.Abs(Float.NegativeInfinity).Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void CreateCheckedFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateChecked<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateChecked<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateChecked<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateChecked<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<UInt128>.CreateChecked<Float>(TwoOver127).Should().Be(UInt128.Parse("170141183460469231731687303715884105728"));
-			NumberBaseHelper<UInt256>.CreateChecked<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateChecked<Float>(TwoOver511)
-				.Should().Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateChecked<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateChecked<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateChecked<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateSaturatingFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateSaturating<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateSaturating<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateSaturating<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateSaturating<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<UInt128>.CreateSaturating<Float>(TwoOver127).Should().Be(UInt128.Parse("170141183460469231731687303715884105728"));
-			NumberBaseHelper<UInt256>.CreateSaturating<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateSaturating<Float>(TwoOver511)
-				.Should().Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateSaturating<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateSaturating<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateSaturating<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateTruncatingFromQuadTest()
-		{
-			NumberBaseHelper<byte>.CreateTruncating<Float>(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<short>.CreateTruncating<Float>(Int16MaxValue).Should().Be(short.MaxValue);
-			NumberBaseHelper<int>.CreateTruncating<Float>(Int32MaxValue).Should().Be(int.MaxValue);
-			NumberBaseHelper<long>.CreateTruncating<Float>(Int64MaxValue).Should().Be(long.MaxValue);
-			NumberBaseHelper<UInt128>.CreateTruncating<Float>(TwoOver127).Should().Be(UInt128.Parse("170141183460469231731687303715884105728"));
-			NumberBaseHelper<UInt256>.CreateTruncating<Float>(TwoOver255)
-				.Should().Be(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			NumberBaseHelper<UInt512>.CreateTruncating<Float>(TwoOver511)
-				.Should().Be(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-
-			NumberBaseHelper<Half>.CreateTruncating<Float>(Half).Should().Be((Half)0.5f);
-			NumberBaseHelper<float>.CreateTruncating<Float>(Half).Should().Be(0.5f);
-			NumberBaseHelper<double>.CreateTruncating<Float>(Half).Should().Be(0.5d);
-		}
-		[Fact]
-		public static void CreateCheckedToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateChecked<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateChecked<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateChecked<UInt128>(UInt128.Parse("170141183460469231731687303715884105728"))
-				.Should().Be(TwoOver127);
-			NumberBaseHelper<Float>.CreateChecked<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateChecked<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateChecked<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateChecked<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateChecked<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void CreateSaturatingToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateSaturating<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateSaturating<UInt128>(UInt128.Parse("170141183460469231731687303715884105728"))
-				.Should().Be(TwoOver127);
-			NumberBaseHelper<Float>.CreateSaturating<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateSaturating<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateSaturating<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateSaturating<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateSaturating<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void CreateTruncatingToQuadTest()
-		{
-			NumberBaseHelper<Float>.CreateTruncating<byte>(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<short>(short.MaxValue).Should().Be(Int16MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<int>(int.MaxValue).Should().Be(Int32MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<long>(long.MaxValue).Should().Be(Int64MaxValue);
-			NumberBaseHelper<Float>.CreateTruncating<UInt128>(UInt128.Parse("170141183460469231731687303715884105728"))
-				.Should().Be(TwoOver127);
-			NumberBaseHelper<Float>.CreateTruncating<UInt256>(UInt256.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"))
-				.Should().Be(TwoOver255);
-			NumberBaseHelper<Float>.CreateTruncating<UInt512>(UInt512.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"))
-				.Should().Be(TwoOver511);
-
-			NumberBaseHelper<Float>.CreateTruncating<Half>((Half)0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateTruncating<float>(0.5f).Should().Be(Half);
-			NumberBaseHelper<Float>.CreateTruncating<double>(0.5d).Should().Be(Half);
-		}
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<Float>.IsCanonical(One).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<Float>.IsComplexNumber(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsEvenInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(Two).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(Three).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(Four).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeTwo).Should().BeTrue();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeThree).Should().BeFalse();
-			NumberBaseHelper<Float>.IsEvenInteger(NegativeFour).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<Float>.IsFinite(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsFinite(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsFinite(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsFinite(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsFinite(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<Float>.IsImaginaryNumber(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInfinity(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInfinity(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsInteger(Quarter).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Thousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(GreaterThanOneSmallest).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(SmallestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(NegativeThousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsInteger(NegativeHalf).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(NegativeQuarter).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsInteger(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<Float>.IsNaN(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(Float.NaN).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNaN(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNaN(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<Float>.IsNegative(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(GreatestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegative(Float.NaN).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegative(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNegative(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsNegativeInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.PositiveInfinity).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNegativeInfinity(Float.NegativeInfinity).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<Float>.IsNormal(GreatestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNormal(SmallestSubnormal).Should().BeFalse();
-			NumberBaseHelper<Float>.IsNormal(MaxValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNormal(MinValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsNormal(One).Should().BeTrue();
-		}
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<Float>.IsOddInteger(Half).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(Two).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(Three).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(Four).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeOne).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeTwo).Should().BeFalse();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeThree).Should().BeTrue();
-			NumberBaseHelper<Float>.IsOddInteger(NegativeFour).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<Float>.IsPositive(One).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositive(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositive(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositive(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<Float>.IsPositiveInfinity(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(NegativeOne).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.NaN).Should().BeFalse();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsPositiveInfinity(Float.NegativeInfinity).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<Float>.IsRealNumber(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(MaxValue).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(NegativeThousand).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.PositiveInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.NegativeInfinity).Should().BeTrue();
-			NumberBaseHelper<Float>.IsRealNumber(Float.NaN).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<Float>.IsSubnormal(GreatestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsSubnormal(SmallestSubnormal).Should().BeTrue();
-			NumberBaseHelper<Float>.IsSubnormal(MaxValue).Should().BeFalse();
-			NumberBaseHelper<Float>.IsSubnormal(MinValue).Should().BeFalse();
-			NumberBaseHelper<Float>.IsSubnormal(One).Should().BeFalse();
-		}
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<Float>.IsZero(One).Should().BeFalse();
-			NumberBaseHelper<Float>.IsZero(Float.Epsilon).Should().BeFalse();
-			NumberBaseHelper<Float>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<Float>.IsZero(NegativeZero).Should().BeTrue();
-		}
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<Float>.MaxMagnitude(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberBaseHelper<Float>.MaxMagnitude(NegativeOne, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(NegativeZero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberBaseHelper<Float>.MaxMagnitude(Zero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberBaseHelper<Float>.MaxMagnitude(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.NegativeInfinity, One)
-				.Should().Be(Float.NegativeInfinity);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.MinValue, One)
-				.Should().Be(Float.MinValue);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(NegativeOne, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(-GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(-Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(NegativeZero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Zero, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.Epsilon, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(GreatestSubnormal, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.MaxValue, One)
-				.Should().Be(Float.MaxValue);
-			NumberBaseHelper<Float>.MaxMagnitudeNumber(Float.PositiveInfinity, One)
-				.Should().Be(Float.PositiveInfinity);
-		}
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<Float>.MinMagnitude(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.MinValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberBaseHelper<Float>.MinMagnitude(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitude(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitude(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberBaseHelper<Float>.MinMagnitude(Float.NaN, One)
-				.Should().Be(Float.NaN);
-			NumberBaseHelper<Float>.MinMagnitude(Zero, One)
-				.Should().Be(Zero);
-			NumberBaseHelper<Float>.MinMagnitude(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitude(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitude(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitude(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.NegativeInfinity, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.MinValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(NegativeOne, One)
-				.Should().Be(NegativeOne);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(-GreatestSubnormal, One)
-				.Should().Be(-GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(-Float.Epsilon, One)
-				.Should().Be(-Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(NegativeZero, One)
-				.Should().Be(NegativeZero);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.NaN, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Zero, One)
-				.Should().Be(Zero);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.Epsilon, One)
-				.Should().Be(Float.Epsilon);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(GreatestSubnormal, One)
-				.Should().Be(GreatestSubnormal);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(One, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.MaxValue, One)
-				.Should().Be(One);
-			NumberBaseHelper<Float>.MinMagnitudeNumber(Float.PositiveInfinity, One)
-				.Should().Be(One);
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void ParseTest(string s, bool success, Float output)
-		{
-			if (success)
-			{
-				NumberBaseHelper<Float>.Parse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo)
-					.Should().Be(output);
-			}
-			else
-			{
-				Assert.Throws<FormatException>(() => NumberBaseHelper<Float>.Parse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo));
-			}
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void TryParseTest(string s, bool success, Float output)
-		{
-			Float result;
-
-			NumberBaseHelper<Float>.TryParse(s, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out result).Should().Be(success);
-			result.Should().Be(output);
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void ParseUtf8Test(string s, bool success, Float output)
-		{
-			byte[] utf8 = Encoding.UTF8.GetBytes(s);
-
-			if (success)
-			{
-				NumberBaseHelper<Float>.Parse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo)
-					.Should().Be(output);
-			}
-			else
-			{
-				Assert.Throws<FormatException>(() => NumberBaseHelper<Float>.Parse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo));
-			}
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void TryParseUtf8Test(string s, bool success, Float output)
-		{
-			ReadOnlySpan<byte> utf8 = Encoding.UTF8.GetBytes(s);
-			Float result;
-
-			NumberBaseHelper<Float>.TryParse(utf8, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out result).Should().Be(success);
-			result.Should().Be(output);
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/QuadTest.TheoryData.cs b/src/MissingValues.Tests/Core/QuadTest.TheoryData.cs
deleted file mode 100644
index 8037eb2..0000000
--- a/src/MissingValues.Tests/Core/QuadTest.TheoryData.cs
+++ /dev/null
@@ -1,798 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Globalization;
-using System.Xml;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class QuadTest
-	{
-#pragma warning disable S3263 // Static fields should appear in the order they must be initialized 
-		private static (string, bool, Quad)[] _tryParseData =>
-		[
-			("2,0", true, Two),
-			("-2", true, NegativeTwo),
-			("0", true, Zero),
-			(NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol, true, Quad.PositiveInfinity),
-			(NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol, true, Quad.NegativeInfinity),
-			(NumberFormatInfo.CurrentInfo.NaNSymbol, true, Quad.NaN),
-			("256,4995", true, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5)),
-			("471581881", true, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000)),
-			("1,93561113", true, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762)),
-			("9715574,2", true, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666)),
-			("0,51438427732005011792", true, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9)),
-			("0,04201133209656899095", true, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947)),
-			("7,7E777", true, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4)),
-			("-7,7E-777", true, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572)),
-			("1A", false, default),
-		];
-
-		private static (Quad, Quad)[] _unaryNegationOperationData =>
-		[
-			(Zero, NegativeZero),
-			(One, NegativeOne),
-			(Two, NegativeTwo),
-			(Ten, NegativeTen),
-			(Hundred, NegativeHundred),
-			(Thousand, NegativeThousand)
-		];
-		private static (Quad, Quad)[] _incrementOperationData =>
-		[
-			(NegativeTwo, NegativeOne),
-			(NegativeOne, Zero),
-			(Zero, One),
-			(One, Two),
-		];
-		private static (Quad, Quad)[] _decrementOperationData =>
-		[
-			(NegativeOne, NegativeTwo),
-			(Zero, NegativeOne),
-			(One, Zero),
-			(Two, One),
-		];
-
-		private static (Quad, Quad, Quad)[] _additionOperationData =>
-		[
-			(One, One, Two),
-			(One, NegativeOne, Zero),
-			(One, NegativeTwo, NegativeOne),
-			(One, Four, Five),
-			(Three, Two, Five),
-			(SmallestSubnormal, GreatestSubnormal, Values.CreateFloat<Quad>(0x0001_0000_0000_0000, 0x0000_0000_0000_0000)),
-			(Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity),
-			(Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity),
-			(Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.PositiveInfinity),
-			(Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NegativeInfinity),
-		];
-		private static (Quad, Quad, Quad)[] _subtractionOperationData =>
-		[
-			(One, One, Zero),
-			(One, NegativeOne, Two),
-			(One, Two, NegativeOne),
-			(SmallestSubnormal, GreatestSubnormal, Values.CreateFloat<Quad>(0x8000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)),
-			(Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.NaN),
-			(Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NaN),
-		];
-		private static (Quad, Quad, Quad)[] _multiplicationOperationData =>
-		[
-			(One, One, One),
-			(One, NegativeOne, NegativeOne),
-			(Ten, Ten, Hundred),
-			(NegativeHundred, Ten, NegativeThousand),
-			(NegativeTen, Hundred, NegativeThousand),
-			(Zero, NegativeThousand, NegativeZero),
-			(Zero, Quad.PositiveInfinity, Quad.NaN),
-			(NegativeZero, Quad.NegativeInfinity, Quad.NaN),
-			(Quad.PositiveInfinity, Zero, Quad.NaN),
-			(Quad.NegativeInfinity, NegativeZero, Quad.NaN),
-		];
-		private static (Quad, Quad, Quad)[] _divisionOperationData =>
-		[
-			(Ten, Ten, One),
-			(Hundred, Ten, Ten),
-			(NegativeThousand, Ten, NegativeHundred),
-			(Zero, Zero, Quad.NaN),
-			(One, Zero, Quad.PositiveInfinity),
-			(NegativeOne, Zero, Quad.NegativeInfinity),
-			(Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.NaN),
-			(Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NaN),
-		];
-
-		private static (byte, Quad)[] _castFromByteData =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(byte.MaxValue, ByteMaxValue),
-		];
-		private static (ushort, Quad)[] _castFromUInt16Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-		];
-		private static (uint, Quad)[] _castFromUInt32Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-		];
-		private static (ulong, Quad)[] _castFromUInt64Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-		];
-		private static (UInt128, Quad)[] _castFromUInt128Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-		];
-		private static (UInt256, Quad)[] _castFromUInt256Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-		];
-		private static (UInt512, Quad)[] _castFromUInt512Data =>
-		[
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(byte.MaxValue, ByteMaxValue),
-			(ushort.MaxValue, UInt16MaxValue),
-			(uint.MaxValue, UInt32MaxValue),
-			(ulong.MaxValue, UInt64MaxValue),
-		];
-		private static (sbyte, Quad)[] _castFromSByteData =>
-		[
-			(sbyte.MinValue, SByteMinValue),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(sbyte.MaxValue, SByteMaxValue),
-		];
-		private static (short, Quad)[] _castFromInt16Data =>
-		[
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-		];
-		private static (int, Quad)[] _castFromInt32Data =>
-		[
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-		];
-		private static (long, Quad)[] _castFromInt64Data =>
-		[
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-		];
-		private static (Int128, Quad)[] _castFromInt128Data =>
-		[
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-		];
-		private static (Int256, Quad)[] _castFromInt256Data =>
-		[
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-		];
-		private static (Int512, Quad)[] _castFromInt512Data =>
-		[
-			(long.MinValue, Int64MinValue),
-			(int.MinValue, Int32MinValue),
-			(short.MinValue, Int16MinValue),
-			(sbyte.MinValue, SByteMinValue),
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-			(sbyte.MaxValue, SByteMaxValue),
-			(short.MaxValue, Int16MaxValue),
-			(int.MaxValue, Int32MaxValue),
-			(long.MaxValue, Int64MaxValue),
-		];
-		private static (Half, Quad)[] _castFromHalfData =>
-		[
-			(System.Half.NegativeOne, NegativeOne),
-			(System.Half.NegativeZero, NegativeZero),
-			(System.Half.Zero, Zero),
-			(System.Half.One, One),
-			((Half)10, Ten),
-			((Half)100, Hundred),
-			((Half)1000, Thousand),
-		];
-		private static (float, Quad)[] _castFromSingleData =>
-		[
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-		];
-		private static (double, Quad)[] _castFromDoubleData =>
-		[
-			(-1000, NegativeThousand),
-			(-100, NegativeHundred),
-			(-10, NegativeTen),
-			(-2, NegativeTwo),
-			(-1, NegativeOne),
-			(0, Zero),
-			(1, One),
-			(2, Two),
-			(10, Ten),
-			(100, Hundred),
-			(1000, Thousand),
-		];
-		
-		private static (Quad, byte)[] _castToByteData =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(ByteMaxValue, byte.MaxValue),
-		];
-		private static (Quad, ushort)[] _castToUInt16Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-		];
-		private static (Quad, uint)[] _castToUInt32Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-		];
-		private static (Quad, ulong)[] _castToUInt64Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-		];
-		private static (Quad, UInt128)[] _castToUInt128Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-		];
-		private static (Quad, UInt256)[] _castToUInt256Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-		];
-		private static (Quad, UInt512)[] _castToUInt512Data =>
-		[
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(Thousand, 1000),
-			(ByteMaxValue, byte.MaxValue),
-			(UInt16MaxValue, ushort.MaxValue),
-			(UInt32MaxValue, uint.MaxValue),
-			(UInt64MaxValue, ulong.MaxValue),
-		];
-		private static (Quad, sbyte)[] _castToSByteData =>
-		[
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-		];
-		private static (Quad, short)[] _castToInt16Data =>
-		[
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-		];
-		private static (Quad, int)[] _castToInt32Data =>
-		[
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-		];
-		private static (Quad, long)[] _castToInt64Data =>
-		[
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-		];
-		private static (Quad, Int128)[] _castToInt128Data =>
-		[
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-		];
-		private static (Quad, Int256)[] _castToInt256Data =>
-		[
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-		];
-		private static (Quad, Int512)[] _castToInt512Data =>
-		[
-			(Int64MinValue, long.MinValue),
-			(Int32MinValue, int.MinValue),
-			(Int16MinValue, short.MinValue),
-			(SByteMinValue, sbyte.MinValue),
-			(NegativeHundred, -100),
-			(NegativeTen, -10),
-			(NegativeTwo, -2),
-			(NegativeOne, -1),
-			(Half, 0),
-			(One, 1),
-			(Two, 2),
-			(Ten, 10),
-			(Hundred, 100),
-			(SByteMaxValue, sbyte.MaxValue),
-			(Int16MaxValue, short.MaxValue),
-			(Int32MaxValue, int.MaxValue),
-			(Int64MaxValue, long.MaxValue),
-		];
-		private static (Quad, Half)[] _castToHalfData =>
-		[
-			(NegativeHundred, -(Half)100.0f),
-			(NegativeTen, -(Half)10.0f),
-			(NegativeTwo, -(Half)2.0f),
-			(NegativeOne, -(Half)1.0f),
-			(NegativeZero, -(Half)0.0f),
-			(Zero, (Half)0.0f),
-			(One, System.Half.One),
-			(Two, (Half)2.0f),
-			(Ten, (Half)10.0f),
-			(Hundred, (Half)100.0f),
-		];
-		private static (Quad, float)[] _castToSingleData =>
-		[
-			(NegativeThousand, -1000.0f),
-			(NegativeHundred, -100.0f),
-			(NegativeTen, -10.0f),
-			(NegativeTwo, -2.0f),
-			(NegativeOne, -1.0f),
-			(NegativeZero, -0.0f),
-			(Zero, 0.0f),
-			(Half, 0.5f),
-			(One, 1.0f),
-			(Two, 2.0f),
-			(Ten, 10.0f),
-			(Hundred, 100.0f),
-			(Thousand, 1000.0f),
-		];
-		private static (Quad, double)[] _castToDoubleData =>
-		[
-			(NegativeThousand, -1000.0d),
-			(NegativeHundred, -100.0d),
-			(NegativeTen, -10.0d),
-			(NegativeTwo, -2.0d),
-			(NegativeOne, -1.0d),
-			(NegativeZero, -0.0d),
-			(Zero, 0.0d),
-			(Half, 0.5d),
-			(One, 1.0d),
-			(Two, 2.0d),
-			(Ten, 10.0d),
-			(Hundred, 100.0d),
-			(Thousand, 1000.0d),
-		];
-		private static (Quad, Octo)[] _castToOctoData =>
-		[
-			(NegativeThousand, OctoTest.NegativeThousand),
-			(NegativeHundred, OctoTest.NegativeHundred),
-			(NegativeTen, OctoTest.NegativeTen),
-			(NegativeTwo, OctoTest.NegativeTwo),
-			(NegativeOne, OctoTest.NegativeOne),
-			(NegativeZero, OctoTest.NegativeZero),
-			(Zero, OctoTest.Zero),
-			(Half, OctoTest.Half),
-			(One, OctoTest.One),
-			(Two, OctoTest.Two),
-			(Ten, OctoTest.Ten),
-			(Hundred, OctoTest.Hundred),
-			(Thousand, OctoTest.Thousand),
-		];
-
-		private static (Quad, int, MidpointRounding, Quad)[] _roundAwayFromZeroData =>
-		[
-			(Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Four),
-			(Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Three),
-			(Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Three),
-			(Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Two),
-			(Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, NegativeFour),
-		];
-		private static (Quad, int, MidpointRounding, Quad)[] _roundToEvenData =>
-		[
-			(Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Four),
-			(Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Three),
-			(Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Two),
-			(Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Two),
-			(Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, NegativeFour),
-		];
-		private static (Quad, int, MidpointRounding, Quad)[] _roundToNegativeInfinityData =>
-		[
-			(Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Three),
-			(Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Two),
-			(Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, NegativeThree),
-			(Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, NegativeFour),
-		];
-		private static (Quad, int, MidpointRounding, Quad)[] _roundToPositiveInfinityData =>
-		[
-			(Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Four),
-			(Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Three),
-			(Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, NegativeThree),
-		];
-		private static (Quad, int, MidpointRounding, Quad)[] _roundToZeroData =>
-		[
-			(Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Three),
-			(Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Two),
-			(Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, NegativeTwo),
-			(Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, NegativeThree),
-		];
-
-		private static (Quad, Quad, bool)[] _greaterThanData =>
-		[
-			(Two, One, true),
-			(Thousand, NegativeThousand, true),
-			(NegativeQuarter, NegativeHalf, true),
-			(Quarter, Half, false),
-			(Ten, Hundred, false),
-			(GreaterThanOneSmallest, One, true),
-		];
-		private static (Quad, Quad, bool)[] _lessThanData =>
-		[
-			(Zero, One, true),
-			(Zero, Quarter, true),
-			(NegativeThousand, Thousand, true),
-			(NegativeOne, NegativeThree, false),
-			(Hundred, Two, false),
-			(LessThanOneLargest, One, true),
-		];
-		private static (Quad, Quad, bool)[] _equalToData =>
-		[
-			(One, One, true), 
-			(Two, Two, true),
-			(Quad.NaN, Quad.NaN, false),
-			(GreatestSubnormal, GreatestSubnormal, true),
-		];
-		private static (Quad, Quad, bool)[] _notEqualToData =>
-		[
-			(One, One, false),
-			(Quad.NaN, Quad.NaN, true),
-			(NegativeTwo, Two, true),
-			(SmallestSubnormal, GreatestSubnormal, true)
-		];
-
-		private static (Quad, Quad, Quad, Quad)[] _fmaData =>
-		[
-			(One, One, One, Two),
-			(Ten, Ten, Zero, Hundred),
-			(Five, Zero, Five, Five),
-			(Values.CreateFloat<Quad>(0xBFFF_4000_0000_0000, 0), One, Two, Values.CreateFloat<Quad>(0x3FFE_8000_0000_0000, 0))
-		];
-
-
-		public static TryParseTheoryData<Quad> TryParseTheoryData = new(_tryParseData);
-
-		public static UnaryTheoryData<Quad, Quad> UnaryNegationOperationTheoryData = new(_unaryNegationOperationData);
-		public static UnaryTheoryData<Quad, Quad> IncrementOperationTheoryData = new(_incrementOperationData);
-		public static UnaryTheoryData<Quad, Quad> DecrementOperationTheoryData = new(_decrementOperationData);
-
-		public static OperationTheoryData<Quad, Quad, Quad> AdditionOperationTheoryData = new(_additionOperationData);
-		public static OperationTheoryData<Quad, Quad, Quad> SubtractionOperationTheoryData = new(_subtractionOperationData);
-		public static OperationTheoryData<Quad, Quad, Quad> MultiplicationOperationTheoryData = new(_multiplicationOperationData);
-		public static OperationTheoryData<Quad, Quad, Quad> DivisionOperationTheoryData = new(_divisionOperationData);
-
-		public static CastingTheoryData<byte, Quad> CastFromByteTheoryData = new(_castFromByteData);
-		public static CastingTheoryData<ushort, Quad> CastFromUInt16TheoryData = new(_castFromUInt16Data);
-		public static CastingTheoryData<uint, Quad> CastFromUInt32TheoryData = new(_castFromUInt32Data);
-		public static CastingTheoryData<ulong, Quad> CastFromUInt64TheoryData = new(_castFromUInt64Data);
-		public static CastingTheoryData<UInt128, Quad> CastFromUInt128TheoryData = new(_castFromUInt128Data);
-		public static CastingTheoryData<UInt256, Quad> CastFromUInt256TheoryData = new(_castFromUInt256Data);
-		public static CastingTheoryData<UInt512, Quad> CastFromUInt512TheoryData = new(_castFromUInt512Data);
-		public static CastingTheoryData<sbyte, Quad> CastFromSByteTheoryData = new(_castFromSByteData);
-		public static CastingTheoryData<short, Quad> CastFromInt16TheoryData = new(_castFromInt16Data);
-		public static CastingTheoryData<int, Quad> CastFromInt32TheoryData = new(_castFromInt32Data);
-		public static CastingTheoryData<long, Quad> CastFromInt64TheoryData = new(_castFromInt64Data);
-		public static CastingTheoryData<Int128, Quad> CastFromInt128TheoryData = new(_castFromInt128Data);
-		public static CastingTheoryData<Int256, Quad> CastFromInt256TheoryData = new(_castFromInt256Data);
-		public static CastingTheoryData<Int512, Quad> CastFromInt512TheoryData = new(_castFromInt512Data);
-		public static CastingTheoryData<Half, Quad> CastFromHalfTheoryData = new(_castFromHalfData);
-		public static CastingTheoryData<float, Quad> CastFromSingleTheoryData = new(_castFromSingleData);
-		public static CastingTheoryData<double, Quad> CastFromDoubleTheoryData = new(_castFromDoubleData);
-
-		public static CastingTheoryData<Quad, byte> CastToByteTheoryData = new(_castToByteData);
-		public static CastingTheoryData<Quad, ushort> CastToUInt16TheoryData = new(_castToUInt16Data);
-		public static CastingTheoryData<Quad, uint> CastToUInt32TheoryData = new(_castToUInt32Data);
-		public static CastingTheoryData<Quad, ulong> CastToUInt64TheoryData = new(_castToUInt64Data);
-		public static CastingTheoryData<Quad, UInt128> CastToUInt128TheoryData = new(_castToUInt128Data);
-		public static CastingTheoryData<Quad, UInt256> CastToUInt256TheoryData = new(_castToUInt256Data);
-		public static CastingTheoryData<Quad, UInt512> CastToUInt512TheoryData = new(_castToUInt512Data);
-		public static CastingTheoryData<Quad, sbyte> CastToSByteTheoryData = new(_castToSByteData);
-		public static CastingTheoryData<Quad, short> CastToInt16TheoryData = new(_castToInt16Data);
-		public static CastingTheoryData<Quad, int> CastToInt32TheoryData = new(_castToInt32Data);
-		public static CastingTheoryData<Quad, long> CastToInt64TheoryData = new(_castToInt64Data);
-		public static CastingTheoryData<Quad, Int128> CastToInt128TheoryData = new(_castToInt128Data);
-		public static CastingTheoryData<Quad, Int256> CastToInt256TheoryData = new(_castToInt256Data);
-		public static CastingTheoryData<Quad, Int512> CastToInt512TheoryData = new(_castToInt512Data);
-		public static CastingTheoryData<Quad, Half> CastToHalfTheoryData = new(_castToHalfData);
-		public static CastingTheoryData<Quad, float> CastToSingleTheoryData = new(_castToSingleData);
-		public static CastingTheoryData<Quad, double> CastToDoubleTheoryData = new(_castToDoubleData);
-		public static CastingTheoryData<Quad, Octo> CastToOctoTheoryData = new(_castToOctoData);
-
-		public static RoundTheoryData<Quad> RoundAwayFromZeroTheoryData = new(_roundAwayFromZeroData);
-		public static RoundTheoryData<Quad> RoundToEvenTheoryData = new(_roundToEvenData);
-		public static RoundTheoryData<Quad> RoundToNegativeInfinityTheoryData = new(_roundToNegativeInfinityData);
-		public static RoundTheoryData<Quad> RoundToPositiveInfinityTheoryData = new(_roundToPositiveInfinityData);
-		public static RoundTheoryData<Quad> RoundToZeroTheoryData = new(_roundToZeroData);
-
-		public static ComparisonOperatorsTheoryData<Quad, Quad> GreaterThanTheoryData = new(_greaterThanData);
-		public static ComparisonOperatorsTheoryData<Quad, Quad> LessThanTheoryData = new(_lessThanData);
-		public static ComparisonOperatorsTheoryData<Quad, Quad> EqualToTheoryData = new(_equalToData);
-		public static ComparisonOperatorsTheoryData<Quad, Quad> NotEqualToTheoryData = new(_notEqualToData);
-
-		public static FusedMultiplyAddTheoryData<Quad> FMATheoryData = new(_fmaData);
-#pragma warning restore S3263 // Static fields should appear in the order they must be initialized 
-	}
-}
diff --git a/src/MissingValues.Tests/Core/QuadTest.cs b/src/MissingValues.Tests/Core/QuadTest.cs
deleted file mode 100644
index 8abefb7..0000000
--- a/src/MissingValues.Tests/Core/QuadTest.cs
+++ /dev/null
@@ -1,466 +0,0 @@
-using MissingValues.Internals;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class QuadTest
-	{
-		public static readonly Quad NegativeThousand = Values.CreateFloat<Quad>(0xC008_F400_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeHundred = Values.CreateFloat<Quad>(0xC005_9000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeTen = Values.CreateFloat<Quad>(0xC002_4000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeSix = Values.CreateFloat<Quad>(0xC001_8000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeFive = Values.CreateFloat<Quad>(0xC001_4000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeFour = Values.CreateFloat<Quad>(0xC001_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeThree = Values.CreateFloat<Quad>(0xC000_8000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeTwo = Values.CreateFloat<Quad>(0xC000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeOne = Quad.NegativeOne;
-		public static readonly Quad NegativeHalf = Values.CreateFloat<Quad>(0xBFFE_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeQuarter = Values.CreateFloat<Quad>(0xBFFD_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad NegativeZero = Quad.NegativeZero;
-		public static readonly Quad Zero = Quad.Zero;
-		public static readonly Quad Quarter = Values.CreateFloat<Quad>(0x3FFD_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Half = Values.CreateFloat<Quad>(0x3FFE_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad One = Quad.One;
-		public static readonly Quad Two = Values.CreateFloat<Quad>(0x4000_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Three = Values.CreateFloat<Quad>(0x4000_8000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Four = Values.CreateFloat<Quad>(0x4001_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Five = Values.CreateFloat<Quad>(0x4001_4000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Six = Values.CreateFloat<Quad>(0x4001_8000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Ten = Values.CreateFloat<Quad>(0x4002_4000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Hundred = Values.CreateFloat<Quad>(0x4005_9000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Thousand = Values.CreateFloat<Quad>(0x4008_F400_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Quad GreaterThanOneSmallest = Values.CreateFloat<Quad>(0x3FFF_0000_0000_0000, 0x0000_0000_0000_0001);
-		public static readonly Quad LessThanOneLargest = Values.CreateFloat<Quad>(0x3FFE_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		public static readonly Quad SmallestSubnormal = Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-		public static readonly Quad GreatestSubnormal = Values.CreateFloat<Quad>(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		public static readonly Quad MaxValue = Quad.MaxValue;
-		public static readonly Quad MinValue = Quad.MinValue;
-
-		public static readonly Quad ByteMaxValue = Values.CreateFloat<Quad>(0x4006_FE00_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad UInt16MaxValue = Values.CreateFloat<Quad>(0x400E_FFFE_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad UInt32MaxValue = Values.CreateFloat<Quad>(0x401E_FFFF_FFFE_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad UInt64MaxValue = Values.CreateFloat<Quad>(0x403E_FFFF_FFFF_FFFF, 0xFFFE_0000_0000_0000);
-		public static readonly Quad TwoOver127 = Values.CreateFloat<Quad>(0x407E_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad TwoOver255 = Values.CreateFloat<Quad>(0x40FE_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad TwoOver511 = Values.CreateFloat<Quad>(0x41FE_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Quad SByteMaxValue = Values.CreateFloat<Quad>(0x4005_FC00_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad SByteMinValue = Values.CreateFloat<Quad>(0xC006_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Int16MaxValue = Values.CreateFloat<Quad>(0x400D_FFFC_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Int16MinValue = Values.CreateFloat<Quad>(0xC00E_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Int32MaxValue = Values.CreateFloat<Quad>(0x401D_FFFF_FFFC_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Int32MinValue = Values.CreateFloat<Quad>(0xC01E_0000_0000_0000, 0x0000_0000_0000_0000);
-		public static readonly Quad Int64MaxValue = Values.CreateFloat<Quad>(0x403D_FFFF_FFFF_FFFF, 0xFFFC_0000_0000_0000);
-		public static readonly Quad Int64MinValue = Values.CreateFloat<Quad>(0xC03E_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly Quad Delta = Values.CreateFloat<Quad>(0x406F_0000_0000_0000, 0x0000_0000_0000_0000);
-
-		public static readonly int Radix = 2;
-
-
-		[Fact]
-		public void Ctor_Empty()
-		{
-			var i = new Quad();
-			Assert.Equal(Zero, i);
-		}
-
-		[Theory]
-		[MemberData(nameof(CastFromByteTheoryData))]
-		public void Cast_FromByte(byte from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt16TheoryData))]
-		public void Cast_FromUInt16(ushort from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt32TheoryData))]
-		public void Cast_FromUInt32(uint from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt64TheoryData))]
-		public void Cast_FromUInt64(ulong from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt128TheoryData))]
-		public void Cast_FromUInt128(UInt128 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt256TheoryData))]
-		public void Cast_FromUInt256(UInt256 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromUInt512TheoryData))]
-		public void Cast_FromUInt512(UInt512 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromSByteTheoryData))]
-		public void Cast_FromSByte(sbyte from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt16TheoryData))]
-		public void Cast_FromInt16(short from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt32TheoryData))]
-		public void Cast_FromInt32(int from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt64TheoryData))]
-		public void Cast_FromInt64(long from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt128TheoryData))]
-		public void Cast_FromInt128(Int128 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt256TheoryData))]
-		public void Cast_FromInt256(Int256 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromInt512TheoryData))]
-		public void Cast_FromInt512(Int512 from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Fact]
-		public void Cast_FromBigInteger()
-		{
-			TwoOver127.Should()
-				.Be((Quad)BigInteger.Parse("170141183460469231731687303715884105728"));
-			TwoOver255.Should()
-				.Be((Quad)BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"));
-			TwoOver511
-				.Should()
-				.Be((Quad)BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
-		}
-		[Theory]
-		[MemberData(nameof(CastFromHalfTheoryData))]
-		public void Cast_FromHalf(Half from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromSingleTheoryData))]
-		public void Cast_FromSingle(float from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastFromDoubleTheoryData))]
-		public void Cast_FromDouble(double from, Quad to)
-		{
-			((Quad)from).Should().Be(to);
-		}
-
-		[Theory]
-		[MemberData(nameof(CastToByteTheoryData))]
-		public void Cast_ToByte(Quad from, byte to)
-		{
-			((byte)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt16TheoryData))]
-		public void Cast_ToUInt16(Quad from, ushort to)
-		{
-			((ushort)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt32TheoryData))]
-		public void Cast_ToUInt32(Quad from, uint to)
-		{
-			((uint)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt64TheoryData))]
-		public void Cast_ToUInt64(Quad from, ulong to)
-		{
-			((ulong)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt128TheoryData))]
-		public void Cast_ToUInt128(Quad from, UInt128 to)
-		{
-			((UInt128)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt256TheoryData))]
-		public void Cast_ToUInt256(Quad from, UInt256 to)
-		{
-			((UInt256)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToUInt512TheoryData))]
-		public void Cast_ToUInt512(Quad from, UInt512 to)
-		{
-			((UInt512)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToSByteTheoryData))]
-		public void Cast_ToSByte(Quad from, sbyte to)
-		{
-			((sbyte)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt16TheoryData))]
-		public void Cast_ToInt16(Quad from, short to)
-		{
-			((short)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt32TheoryData))]
-		public void Cast_ToInt32(Quad from, int to)
-		{
-			((int)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt64TheoryData))]
-		public void Cast_ToInt64(Quad from, long to)
-		{
-			((long)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt128TheoryData))]
-		public void Cast_ToInt128(Quad from, Int128 to)
-		{
-			((Int128)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt256TheoryData))]
-		public void Cast_ToInt256(Quad from, Int256 to)
-		{
-			((Int256)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToInt512TheoryData))]
-		public void Cast_ToInt512(Quad from, Int512 to)
-		{
-			((Int512)from).Should().Be(to);
-		}
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.Parse("170141183460469231731687303715884105728")
-				.Should().Be((BigInteger)TwoOver127);
-			BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968")
-				.Should().Be((BigInteger)TwoOver255);
-			BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048")
-				.Should().Be((BigInteger)TwoOver511);
-		}
-		[Theory]
-		[MemberData(nameof(CastToHalfTheoryData))]
-		public void Cast_ToHalf(Quad from, Half to)
-		{
-			((Half)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToSingleTheoryData))]
-		public void Cast_ToSingle(Quad from, float to)
-		{
-			((float)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToDoubleTheoryData))]
-		public void Cast_ToDouble(Quad from, double to)
-		{
-			((double)from).Should().Be(to);
-		}
-		[Theory]
-		[MemberData(nameof(CastToOctoTheoryData))]
-		public void Cast_ToOcto(Quad from, Octo to)
-		{
-			((Octo)from).Should().Be(to);
-		}
-
-		[Fact]
-		public void ToGeneralStringTest()
-		{
-			NegativeQuarter.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("-0.25");
-			Half.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("0.5");
-			NegativeHalf.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("-0.5");
-			One.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("1");
-			Thousand.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("1000");
-			NegativeThousand.ToString("G33", CultureInfo.InvariantCulture)
-				.Should().Be("-1000");
-		}
-
-		[Fact]
-		public void ToScientificStringTest()
-		{
-			NegativeQuarter.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("-2.5E-1");
-			Half.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("5E-1");
-			NegativeHalf.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("-5E-1");
-			One.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("1E+0");
-			Thousand.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("1E+3");
-			NegativeThousand.ToString("E33", CultureInfo.InvariantCulture)
-				.Should().Be("-1E+3");
-		}
-
-		[Fact]
-		public void ToGeneralFormatStringTest()
-		{
-			$"{NegativeQuarter:G33}"
-				.Should().Be("-0,25");
-			$"{Half:G33}"
-				.Should().Be("0,5");
-			$"{NegativeHalf:G33}"
-				.Should().Be("-0,5");
-			$"{One:G33}"
-				.Should().Be("1");
-			$"{Thousand:G33}"
-				.Should().Be("1000");
-			$"{NegativeThousand:G33}"
-				.Should().Be("-1000");
-		}
-
-		[Fact]
-		public void ToScientificFormatStringTest()
-		{
-			$"{NegativeQuarter:E33}"
-				.Should().Be("-2,5E-1");
-			$"{Half:E33}"
-				.Should().Be("5E-1");
-			$"{NegativeHalf:E33}"
-				.Should().Be("-5E-1");
-			$"{One:E33}"
-				.Should().Be("1E+0");
-			$"{Thousand:E33}"
-				.Should().Be("1E+3");
-			$"{NegativeThousand:E33}"
-				.Should().Be("-1E+3");
-		}
-
-		[Fact]
-		public void ToGeneralFormatUtf8StringTest()
-		{
-			int bytesWritten;
-			Span<byte> utf8 = stackalloc byte[10];
-
-			Utf8.TryWrite(utf8, $"{NegativeQuarter:G33}", out bytesWritten);
-			Assert.Equal("-0,25"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{Half:G33}", out bytesWritten);
-			Assert.Equal("0,5"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{NegativeHalf:G33}", out bytesWritten);
-			Assert.Equal("-0,5"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{One:G33}", out bytesWritten);
-			Assert.Equal("1"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{Thousand:G33}", out bytesWritten);
-			Assert.Equal("1000"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{NegativeThousand:G33}", out bytesWritten);
-			Assert.Equal("-1000"u8, utf8[..bytesWritten]);
-		}
-
-		[Fact]
-		public void ToScientificFormatUtf8StringTest()
-		{
-			int bytesWritten;
-			Span<byte> utf8 = stackalloc byte[10];
-
-			Utf8.TryWrite(utf8, $"{NegativeQuarter:E33}", out bytesWritten);
-			Assert.Equal("-2,5E-1"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{Half:E33}", out bytesWritten);
-			Assert.Equal("5E-1"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{NegativeHalf:E33}", out bytesWritten);
-			Assert.Equal("-5E-1"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{One:E33}", out bytesWritten);
-			Assert.Equal("1E+0"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{Thousand:E33}", out bytesWritten);
-			Assert.Equal("1E+3"u8, utf8[..bytesWritten]);
-			utf8.Clear();
-
-			Utf8.TryWrite(utf8, $"{NegativeThousand:E33}", out bytesWritten);
-			Assert.Equal("-1E+3"u8, utf8[..bytesWritten]);
-		}
-
-		[Theory]
-		[MemberData(nameof(TryParseTheoryData))]
-		public void BasicTryParseTest(string s, bool success, Quad expected)
-		{
-			Quad.TryParse(s, out Quad actual).Should().Be(success);
-			actual.Should().Be(expected);
-		}
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new Quad[] { MaxValue, One, Half, Quarter, Zero })
-				.Should().Be($"[{MaxValue.ToString(null, CultureInfo.InvariantCulture)},1,0.5,0.25,0]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			string toString = Quarter.ToString(null, CultureInfo.InvariantCulture);
-
-			JsonSerializer.Deserialize<Quad>(toString)
-				.Should().Be(Quarter);
-			JsonSerializer.Deserialize<Quad>(Encoding.UTF8.GetBytes(toString))
-				.Should().Be(Quarter);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/UInt256Test.GenericMath.cs b/src/MissingValues.Tests/Core/UInt256Test.GenericMath.cs
deleted file mode 100644
index 3a88fc2..0000000
--- a/src/MissingValues.Tests/Core/UInt256Test.GenericMath.cs
+++ /dev/null
@@ -1,1180 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-using UInt = MissingValues.UInt256;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class UInt256Test
-	{
-		#region Readonly Variables
-		private const string MaxValueBin =
-			"11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111";
-		private ReadOnlySpan<byte> MaxValueBinUtf8 =>
-			"11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8;
-		private const double MaxValueAsDouble = 115792089237316195423570985008687907853269984665640564039457584007913129639935.0;
-
-		private static readonly UInt ByteMaxValue = new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_00FF));
-		private static readonly UInt UInt16MaxValue = new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF));
-		private static readonly UInt UInt32MaxValue = new(0, new(0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF));
-		private static readonly UInt UInt64MaxValue = new(0, new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF));
-		private static readonly UInt UInt128MaxValue = new(0, new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-
-		private static readonly UInt Zero = new(new (0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new (0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-		private static readonly UInt One = new(new (0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new (0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
-		private static readonly UInt Two = new(new (0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new (0x0000_0000_0000_0000, 0x0000_0000_0000_0002));
-
-		private static readonly UInt MaxValue = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-		private static readonly UInt MaxValueMinusOne = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		private static readonly UInt MaxValueMinusTwo = new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFD));
-
-		private static readonly UInt E40 = new(0x0000_0000_0000_0000, 0x0000_0000_0000_001D, 0x6329_F1C3_5CA4_BFAB, 0xB9F5_6100_0000_0000);
-		#endregion
-
-		#region Generic Math Operators
-		[Fact]
-		public static void op_AdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(Zero, One));
-			Assert.Equal(Two, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Zero, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(MaxValue, One));
-		}
-		[Fact]
-		public static void op_CheckedAdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(Zero, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(One, One));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(MaxValue, 1));
-		}
-		[Fact]	
-		public static void op_IncrementTest()
-		{
-			MathOperatorsHelper.IncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.IncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusTwo).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-			MathOperatorsHelper.IncrementOperation(MaxValue).Should().Be(Zero);
-		}
-		[Fact]	
-		public static void op_CheckedIncrementTest()
-		{
-			MathOperatorsHelper.CheckedIncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.CheckedIncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusTwo).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedIncrementOperation(MaxValue));
-		}
-		[Fact]
-		public static void op_SubtractionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.SubtractionOperation<UInt, UInt, UInt>(Two, One));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.SubtractionOperation<UInt, UInt, UInt>(MaxValue, 1));
-		}
-		[Fact]
-		public static void op_CheckedSubtractionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(Two, One));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(MaxValue, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(Zero, 1));
-		}
-		[Fact]
-		public static void op_DecrementTest()
-		{
-			MathOperatorsHelper.DecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.DecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.DecrementOperation(MaxValueMinusOne).Should().Be(MaxValueMinusTwo);
-			MathOperatorsHelper.DecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.DecrementOperation(Zero).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_CheckedDecrementTest()
-		{
-			MathOperatorsHelper.CheckedDecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.CheckedDecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValueMinusOne).Should().Be(MaxValueMinusTwo);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDecrementOperation(Zero));
-		}
-		[Fact]
-		public static void op_MultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.MultiplicationOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.MultiplicationOperation<UInt, UInt, UInt>(Two, One));
-		}
-		[Fact]
-		public static void op_CheckedMultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(Two, One));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(MaxValue, Two));
-		}
-		[Fact]
-		public static void op_DivisionTest()
-		{
-			Assert.Equal(new UInt(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, Two));
-			Assert.Equal(new UInt(0, 0, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(UInt128.MaxValue, Two));
-			Assert.Equal(new UInt(0x0000_0000_0000_0001, 0xD83C_94FB_6D2A_C34A, 0x5663_D3C7_A0D8_65CA, 0x3C4C_A40E_0EA7_CFE9), MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, 0x8AC7_2304_89E8_0000));
-			
-			Assert.Equal(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0003, 0x671F_73B5_4F1C_8956, 0x5B9E_F4D6_3241_2884), MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, new UInt128(0x4B3B_4CA8_5A86_C47A, 0x098A_2240_0000_0000)));
-			Assert.Equal(One, MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, MaxValue));
-			Assert.Equal(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01), MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, E40));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(One, Zero));
-		}
-		[Fact]
-		public static void op_CheckedDivisionTest()
-		{
-			Assert.Equal(new UInt(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, Two));
-			Assert.Equal(new UInt(0x0000_0000_0000_0001, 0xD83C_94FB_6D2A_C34A, 0x5663_D3C7_A0D8_65CA, 0x3C4C_A40E_0EA7_CFE9), MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, 0x8AC7_2304_89E8_0000));
-			Assert.Equal(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0003, 0x671F_73B5_4F1C_8956, 0x5B9E_F4D6_3241_2884), MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, new UInt128(0x4B3B_4CA8_5A86_C47A, 0x098A_2240_0000_0000)));
-			Assert.Equal(One, MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, MaxValue));
-			Assert.Equal(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01), MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, E40));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(One, Zero));
-		}
-		[Fact]
-		public static void op_ModulusTest()
-		{
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(Two, Two).Should().Be(Zero);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(One, Two).Should().NotBe(Zero);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(MaxValue, new(10U)).Should().Be(5U);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(MaxValue, new(10_000_000_000_000_000_000U)).Should().Be(7584007913129639935U);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(MaxValue, E40)
-				.Should().Be(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0009, 0x9C10_2376_5631_2693, 0x7E70_9EFF_FFFF_FFFF));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(One, Zero));
-		}
-
-		[Fact]
-		public static void op_BitwiseAndTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(Zero, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(One, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(MaxValue, 1U).Should().Be(One);
-		}
-		[Fact]
-		public static void op_BitwiseOrTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(One, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(MaxValue, 1U)
-				.Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_ExclusiveOrTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(One, 1U)
-				.Should().Be(Zero);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(MaxValue, 1U)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)));
-		}
-		[Fact]
-		public static void op_OnesComplementTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(Zero)
-				.Should().Be(MaxValue);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(One)
-				.Should().Be(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE)));
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(MaxValue)
-				.Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void op_LeftShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(One, 1)
-				.Should().Be(Two);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(MaxValue, 1)
-				.Should().Be(MaxValueMinusOne);
-
-			UInt actual = new(0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64)
-				.Should().Be(new(0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 128)
-				.Should().Be(new(0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 192)
-				.Should().Be(new(0xF5C2_8F5C_28F5_C28F, 0, 0, 0));
-		}
-		[Fact]
-		public static void op_RightShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(MaxValue, 1)
-				.Should().Be(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-
-			UInt actual = new(0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64)
-				.Should().Be(new(0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 128)
-				.Should().Be(new(0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 192)
-				.Should().Be(new(0, 0, 0, 0x028F_5C28_F5C2_8F5C));
-		}
-		[Fact]
-		public static void op_UnsignedRightShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(MaxValue, 1)
-				.Should().Be(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
-
-			UInt actual = new(0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64)
-				.Should().Be(new(0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 128)
-				.Should().Be(new(0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 192)
-				.Should().Be(new(0, 0, 0, 0x028F_5C28_F5C2_8F5C));
-		}
-
-		[Fact]
-		public static void op_EqualityTest()
-		{
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(Zero, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(One, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_InequalityTest()
-		{
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(Zero, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(One, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(MaxValue, 1U).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void op_GreaterThanTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(MaxValue, 1U).Should().BeTrue();
-		}
-		[Fact]
-		public static void op_GreaterThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(MaxValue, 1U).Should().BeTrue();
-		}
-		[Fact]
-		public static void op_LessThanTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_LessThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		#endregion
-
-		#region Identities
-		[Fact]
-		public static void AdditiveIdentityTest()
-		{
-			Assert.Equal(Zero, MathConstantsHelper.AdditiveIdentityHelper<UInt, UInt>());
-		}
-
-		[Fact]
-		public static void MultiplicativeIdentityTest()
-		{
-			Assert.Equal(One, MathConstantsHelper.MultiplicativeIdentityHelper<UInt, UInt>());
-		}
-		#endregion
-
-		#region IBinaryInteger
-		[Fact]
-		public static void DivRemTest()
-		{
-			Assert.Equal((Zero, Zero), BinaryIntegerHelper<UInt>.DivRem(Zero, Two));
-			Assert.Equal((Zero, One), BinaryIntegerHelper<UInt>.DivRem(One, Two));
-			Assert.Equal(
-				(new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01), 
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0009, 0x9C10_2376_5631_2693, 0x7E70_9EFF_FFFF_FFFF)),
-				BinaryIntegerHelper<UInt>.DivRem(MaxValue, E40));
-			Assert.Equal((new UInt(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), One), BinaryIntegerHelper<UInt>.DivRem(MaxValue, 2));
-		}
-
-		[Fact]
-		public static void LeadingZeroCountTest()
-		{
-			Assert.Equal(256U, BinaryIntegerHelper<UInt>.LeadingZeroCount(Zero));
-			Assert.Equal(255U, BinaryIntegerHelper<UInt>.LeadingZeroCount(One));
-			Assert.Equal(192U, BinaryIntegerHelper<UInt>.LeadingZeroCount(ulong.MaxValue));
-			Assert.Equal(128U, BinaryIntegerHelper<UInt>.LeadingZeroCount(UInt128.MaxValue));
-			Assert.Equal(64U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue >>> 64));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue));
-		}
-
-		[Fact]
-		public static void PopCountTest()
-		{
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.PopCount(Zero));
-			Assert.Equal(1U, BinaryIntegerHelper<UInt>.PopCount(One));
-			Assert.Equal(256U, BinaryIntegerHelper<UInt>.PopCount(MaxValue));
-		}
-
-		[Fact]
-		public static void RotateLeftTest()
-		{
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<UInt>.RotateLeft(Zero, 1));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0002)), BinaryIntegerHelper<UInt>.RotateLeft(One, 1));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), BinaryIntegerHelper<UInt>.RotateLeft(MaxValue, 1));
-		}
-
-		[Fact]
-		public static void RotateRightTest()
-		{
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<UInt>.RotateRight(Zero, 1));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), BinaryIntegerHelper<UInt>.RotateRight(One, 1));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), BinaryIntegerHelper<UInt>.RotateRight(MaxValue, 1));
-		}
-
-		[Fact]
-		public static void TrailingZeroCountTest()
-		{
-			Assert.Equal(256U, BinaryIntegerHelper<UInt>.TrailingZeroCount(Zero));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.TrailingZeroCount(One));
-			Assert.Equal(1U, BinaryIntegerHelper<UInt>.TrailingZeroCount(Two));
-			Assert.Equal(64U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0,0,1,0)));
-			Assert.Equal(128U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0,1,0,0)));
-			Assert.Equal(192U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(1,0,0,0)));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.TrailingZeroCount(MaxValue));
-		}
-
-		[Fact]
-		public static void TryReadBigEndianInt128Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-		}
-
-		[Fact]
-		public static void TryReadBigEndianUInt128Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadBigEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt128Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt192Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0100_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianInt256Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt128Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt192Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0100_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x8000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0, new UInt128(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt256Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0001)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new(0x0000_0000_0000_0000, 0x0000_0000_0000_0080)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)), result);
-		}
-
-		[Fact]
-		public static void GetByteCountTest()
-		{
-			Assert.Equal(32, BinaryIntegerHelper<UInt>.GetByteCount(Zero));
-			Assert.Equal(32, BinaryIntegerHelper<UInt>.GetByteCount(One));
-			Assert.Equal(32, BinaryIntegerHelper<UInt>.GetByteCount(MaxValue));
-		}
-
-		[Fact]
-		public static void GetShortestBitLengthTest()
-		{
-			Assert.Equal(0x00, BinaryIntegerHelper<UInt>.GetShortestBitLength(Zero));
-			Assert.Equal(0x01, BinaryIntegerHelper<UInt>.GetShortestBitLength(One));
-			Assert.Equal(0x100, BinaryIntegerHelper<UInt>.GetShortestBitLength(MaxValue));
-		}
-
-		[Fact]
-		public static void TryWriteBigEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[32];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(One, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryWriteBigEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-
-		[Fact]
-		public static void TryWriteLittleEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[32];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(One, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(32, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-		#endregion
-
-		#region IBinaryNumber
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			Assert.Equal(BinaryNumberHelper<UInt>.AllBitsSet, ~Zero);
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x100)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x1_0000)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x1_0000_0000)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0, new(0x1, 0x0000_0000_0000_0000))));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x1, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000))));
-		}
-		[Fact]
-		public static void Log2Test()
-		{
-			Assert.Equal(8U, BinaryNumberHelper<UInt>.Log2(new(0x100)));
-			Assert.Equal(16U, BinaryNumberHelper<UInt>.Log2(new(0x1_0000)));
-			Assert.Equal(32U, BinaryNumberHelper<UInt>.Log2(new(0x1_0000_0000)));
-			Assert.Equal(64U, BinaryNumberHelper<UInt>.Log2(new(0, new(0x1, 0x0000_0000_0000_0000))));
-			Assert.Equal(128U, BinaryNumberHelper<UInt>.Log2(new(0x1, new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000))));
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<UInt>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			Zero.Should().Be(MathConstantsHelper.MinValue<UInt>());
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<UInt>.Clamp(MaxValueMinusOne, UInt128MaxValue, MaxValue).Should().Be(MaxValueMinusOne);
-			NumberHelper<UInt>.Clamp(Zero, Two, MaxValue).Should().Be(Two);
-			NumberHelper<UInt>.Clamp(MaxValue, Zero, One).Should().Be(One);
-
-			Assert.Throws<ArgumentException>(() => NumberHelper<UInt>.Clamp(Zero, MaxValue, Zero));
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<UInt>.CopySign(MaxValue, One).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<UInt>.Max(MaxValue, Two).Should().Be(MaxValue);
-			NumberHelper<UInt>.Max(One, Zero).Should().Be(One);
-			NumberHelper<UInt>.Max(Two, Zero).Should().Be(Two);
-			NumberHelper<UInt>.Max(Two, One).Should().Be(Two);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<UInt>.MaxNumber(MaxValue, Zero).Should().Be(MaxValue);
-			NumberHelper<UInt>.MaxNumber(One, Zero).Should().Be(One);
-			NumberHelper<UInt>.MaxNumber(Two, Zero).Should().Be(Two);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<UInt>.Min(MaxValue, Zero).Should().Be(Zero);
-			NumberHelper<UInt>.Min(One,	Zero).Should().Be(Zero);
-			NumberHelper<UInt>.Min(Two, Zero).Should().Be(Zero);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<UInt>.MinNumber(MaxValue, Zero).Should().Be(Zero);
-			NumberHelper<UInt>.MinNumber(One,Zero).Should().Be(Zero);
-			NumberHelper<UInt>.MinNumber(Two, Zero).Should().Be(Zero);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<UInt>.Sign(MaxValue).Should().Be(1);
-			NumberHelper<UInt>.Sign(UInt.Zero).Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<UInt>.Abs(One).Should().Be(One);
-		}
-		[Fact]
-		public static void CreateCheckedToUInt256Test()
-		{
-			NumberBaseHelper<UInt>.CreateChecked(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateChecked(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateChecked(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(UInt128.MinValue).Should().Be(Zero);
-		}
-		[Fact]
-		public static void CreateSaturatingToUInt256Test()
-		{
-			NumberBaseHelper<UInt>.CreateSaturating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateSaturating(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateSaturating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt128.MinValue).Should().Be(Zero);
-		}
-		[Fact]
-		public static void CreateTruncatingToUInt256Test()
-		{
-			NumberBaseHelper<UInt>.CreateTruncating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateTruncating(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateTruncating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt128.MinValue).Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void CreateCheckedFromUInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateChecked(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateChecked(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateChecked(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateChecked(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateChecked(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"));
-			NumberBaseHelper<double>.CreateChecked(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateChecked(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateChecked(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateChecked(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateChecked(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateChecked(Zero).Should().Be(UInt128.MinValue);
-		}
-		[Fact]
-		public static void CreateSaturatingFromUInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateSaturating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateSaturating(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateSaturating(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateSaturating(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateSaturating(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"));
-			NumberBaseHelper<double>.CreateSaturating(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateSaturating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateSaturating(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateSaturating(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateSaturating(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateSaturating(Zero).Should().Be(UInt128.MinValue);
-		}
-		[Fact]
-		public static void CreateTruncatingFromUInt256Test()
-		{
-			NumberBaseHelper<byte>.CreateTruncating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateTruncating(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateTruncating(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateTruncating(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateTruncating(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"115792089237316195423570985008687907853269984665640564039457584007913129639935"));
-			NumberBaseHelper<double>.CreateTruncating(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateTruncating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateTruncating(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateTruncating(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateTruncating(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateTruncating(Zero).Should().Be(UInt128.MinValue);
-		}
-
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<UInt>.IsCanonical(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsComplexNumber(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<UInt>.IsEvenInteger(Two).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<UInt>.IsFinite(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsImaginaryNumber(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsInfinity(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsInteger(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<UInt>.IsNaN(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<UInt>.IsNegative(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsNegativeInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<UInt>.IsNormal(Zero).Should().BeFalse();
-			NumberBaseHelper<UInt>.IsNormal(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsOddInteger(Two).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<UInt>.IsPositive(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsPositiveInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsRealNumber(default).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<UInt>.IsSubnormal(default).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<UInt>.IsZero(default).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsZero(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<UInt>.MaxMagnitude(MaxValue, Zero).Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.MaxMagnitude(One, Zero).Should().Be(One);
-			NumberBaseHelper<UInt>.MaxMagnitude(Two, Zero).Should().Be(Two);
-		}
-
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(MaxValue, Zero).Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(One, Zero).Should().Be(One);
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(Two, Zero).Should().Be(Two);
-		}
-
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<UInt>.MinMagnitude(MaxValue, MaxValueMinusOne).Should().Be(MaxValueMinusOne);
-			NumberBaseHelper<UInt>.MinMagnitude(One, Zero).Should().Be(Zero);
-			NumberBaseHelper<UInt>.MinMagnitude(Two, Zero).Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(MaxValue, MaxValueMinusOne).Should().Be(MaxValueMinusOne);
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(One, Zero).Should().Be(Zero);
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(Two, Zero).Should().Be(Zero);
-		}
-
-		[Fact]
-		public void ParseTest()
-		{
-			NumberBaseHelper<UInt>.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("123456790ABCDEF123456790ABCDEFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0123_4567_90AB_CDEF, 0x1234_5679_0ABC_DEFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0123_4567_90AB_CDEF, 0x1234_5679_0ABC_DEFF));
-
-			NumberBaseHelper<UInt>.Parse(MaxValueBin, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("00010001010101111001001000001000100100100011011100110001011000011000", System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0, 0x0, 0x1, 0x1579_2089_2373_1618))
-				.And.BeRankedEquallyTo(new(0x0, 0x0, 0x1, 0x1579_2089_2373_1618));
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<UInt>.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639936", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseTest()
-		{
-			NumberBaseHelper<UInt>.TryParse("115792089237316195423570985008687907853269984665640564039457584007913129639935", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out UInt parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse(MaxValueBin, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.TryParse("115792089237316195423570985008687907853269984665640564039457584007913129639936", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-
-		[Fact]
-		public void ParseUtf8Test()
-		{
-			NumberBaseHelper<UInt>.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF));
-			NumberBaseHelper<UInt>.Parse("123456790ABCDEF123456790ABCDEFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0123_4567_90AB_CDEF, 0x1234_5679_0ABC_DEFF))
-				.And.BeRankedEquallyTo(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0123_4567_90AB_CDEF, 0x1234_5679_0ABC_DEFF));
-
-			NumberBaseHelper<UInt>.Parse(MaxValueBinUtf8, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("00010001010101111001001000001000100100100011011100110001011000011000"u8, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(new(0x0, 0x0, 0x1, 0x1579_2089_2373_1618))
-				.And.BeRankedEquallyTo(new(0x0, 0x0, 0x1, 0x1579_2089_2373_1618));
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<UInt>.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseUtf8Test()
-		{
-			NumberBaseHelper<UInt>.TryParse("115792089237316195423570985008687907853269984665640564039457584007913129639935"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out UInt parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse(MaxValueBinUtf8, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.TryParse("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-		#endregion
-
-		#region IPowerFunctions
-		[Fact]
-		public void PowTest()
-		{
-			GenericFloatingPointFunctions.Pow(Zero, (uint)int.MaxValue).Should().Be(Zero);
-			GenericFloatingPointFunctions.Pow(One, (uint)int.MaxValue).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, Zero).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, One).Should().Be(MaxValue);
-			GenericFloatingPointFunctions.Pow(Two, Two).Should().Be(4);
-			GenericFloatingPointFunctions.Pow(Two, 4U).Should().Be(16);
-			GenericFloatingPointFunctions.Pow(16U, Two).Should().Be(256);
-			GenericFloatingPointFunctions.Pow(Two, 255U)
-				.Should().Be(new UInt(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two, 256U));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two + Two, 255U));
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/UInt256Test.cs b/src/MissingValues.Tests/Core/UInt256Test.cs
deleted file mode 100644
index a234c97..0000000
--- a/src/MissingValues.Tests/Core/UInt256Test.cs
+++ /dev/null
@@ -1,236 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-
-using UInt = MissingValues.UInt256;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class UInt256Test
-	{
-		[Fact]
-		public void Cast_ToByte()
-		{
-			byte.MinValue.Should().Be((byte)Zero);
-			byte.MaxValue.Should().Be((byte)ByteMaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt16()
-		{
-			ushort.MinValue.Should().Be((ushort)Zero);
-			ushort.MaxValue.Should().Be((ushort)UInt16MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt32()
-		{
-			uint.MinValue.Should().Be((uint)Zero);
-			uint.MaxValue.Should().Be((uint)UInt32MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt64()
-		{
-			ulong.MinValue.Should().Be((ulong)Zero);
-			ulong.MaxValue.Should().Be((ulong)UInt64MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt128()
-		{
-			UInt128.MinValue.Should().Be((UInt128)Zero);
-			UInt128.MaxValue.Should().Be((UInt128)UInt128MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.One.Should().Be((BigInteger)One);
-			BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935")
-				.Should().Be((BigInteger)MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToDouble()
-		{
-			// Test a UInt256Converter value where _upper is 0
-			UInt value1 = new UInt(UInt128.Zero, UInt128.MaxValue);
-			double exp1 = System.Math.Round((double)UInt128.MaxValue, 5);
-			double act1 = System.Math.Round((double)value1, 5);
-			double diff1 = System.Math.Abs(exp1 * 0.00000000001);
-			Assert.True(System.Math.Abs(exp1 - act1) <= diff1);
-
-
-			// Test a UInt256Converter value where _upper is not 0
-			UInt value2 = new UInt(UInt128.MaxValue, UInt128.MaxValue);
-			double exp2 = System.Math.Round(((double)UInt128.MaxValue) * System.Math.Pow(2.0, 128), 5);
-			double act2 = System.Math.Round((double)value2, 5);
-			double diff2 = System.Math.Abs(exp2 * 0.00000000001);
-			Assert.True(System.Math.Abs(exp2 - act2) <= diff2);
-		}
-
-		[Fact]
-		public void BigMulTest()
-		{
-			UInt upper = UInt.BigMul(MaxValue, Two, out UInt lower);
-
-			upper
-				.Should()
-				.Be(new(0x1));
-			lower
-				.Should()
-				.Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		}
-
-		[Fact]
-		public void Internal_DivRemTest()
-		{
-			const long Left = 101_000_000_000;
-			const long Right = 10_000_000_000;
-			const long Quotient = 10;
-			const long Remainder = 1_000_000_000;
-
-			UInt a = Left;
-			UInt b = Right;
-
-			UInt.DivRem(in a, in b, out UInt quotient, out UInt remainder);
-
-			quotient.Should().Be(Quotient);
-			remainder.Should().Be(Remainder);
-
-			UInt.DivRem(in a, in b, out a, out remainder);
-
-			a.Should().Be(Quotient);
-			remainder.Should().Be(Remainder);
-
-			UInt.DivRem(Left, in b, out quotient, out b);
-
-			quotient.Should().Be(Quotient);
-			b.Should().Be(Remainder);
-		}
-
-		[Fact]
-		public void BasicParseTest()
-		{
-			UInt.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935")
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-		}
-
-		[Fact]
-		public void BasicTryParseTest()
-		{
-			UInt.TryParse("115792089237316195423570985008687907853269984665640564039457584007913129639935", out UInt parsedValue).Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-		}
-
-		[Fact]
-		public void ToDecStringTest()
-		{
-			Zero.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("0");
-			One.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			MaxValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("115792089237316195423570985008687907853269984665640564039457584007913129639935");
-		}
-		[Fact]
-		public void ToHexStringTest()
-		{
-			One.ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((UInt)byte.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FF");
-			((UInt)ushort.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFF");
-			((UInt)uint.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFF");
-			((UInt)ulong.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFF");
-			((UInt)UInt128.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-
-			Zero.ToString("X64", CultureInfo.CurrentCulture)
-				.Should().Be("0000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("x64", CultureInfo.CurrentCulture)
-				.Should().Be("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-			MaxValue.ToString("X64", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-		}
-		[Fact]
-		public void ToBinStringTest()
-		{
-			One.ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((UInt)byte.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111");
-			((UInt)ushort.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111");
-			((UInt)uint.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111111111111111111111111111");
-			((UInt)ulong.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111111111111111111111111111111111111");
-			((UInt)UInt128.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-
-			Zero.ToString("B256", CultureInfo.CurrentCulture)
-				.Should().Be("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("B256", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-		}
-
-		[Fact]
-		public void ToDecFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString()!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToHexFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("X64", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:X64}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToBinFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("B256", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:B256}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new object[] { MaxValue, Zero, One })
-				.Should().Be("[115792089237316195423570985008687907853269984665640564039457584007913129639935,0,1]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			JsonSerializer.Deserialize<UInt>("115792089237316195423570985008687907853269984665640564039457584007913129639935")
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<UInt>("115792089237316195423570985008687907853269984665640564039457584007913129639935"u8)
-				.Should().Be(MaxValue);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Core/UInt512Test.GenericMath.cs b/src/MissingValues.Tests/Core/UInt512Test.GenericMath.cs
deleted file mode 100644
index d22d1e5..0000000
--- a/src/MissingValues.Tests/Core/UInt512Test.GenericMath.cs
+++ /dev/null
@@ -1,1172 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-using UInt = MissingValues.UInt512;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class UInt512Test
-	{
-		#region Readonly Variables
-		private const string MaxValueBin =
-			"11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111"
-			+ "11111111111111111111111111111111";
-		private ReadOnlySpan<byte> MaxValueBinUtf8 =>
-			"11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8
-			+ "11111111111111111111111111111111"u8;
-		private const double MaxValueAsDouble = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095.0;
-
-		private static readonly UInt ByteMaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
-		private static readonly UInt UInt16MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF);
-		private static readonly UInt UInt32MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF);
-		private static readonly UInt UInt64MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF);
-		private static readonly UInt UInt128MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-		private static readonly UInt UInt256MaxValue = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		private static readonly UInt Zero = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
-		private static readonly UInt One = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-		private static readonly UInt Two = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
-
-		private static readonly UInt MaxValue = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-		private static readonly UInt MaxValueMinusOne = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
-		private static readonly UInt MaxValueMinusTwo = new(
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFD);
-		private static readonly UInt HalfMaxValue = new(
-			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
-
-		private static readonly UInt E40 = new(
-			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-			0x0000_0000_0000_0000, 0x0000_0000_0000_001D, 0x6329_F1C3_5CA4_BFAB, 0xB9F5_6100_0000_0000);
-		#endregion
-
-		#region Generic Math Operators
-		[Fact]
-		public static void op_AdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(Zero, One));
-			Assert.Equal(Two, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Zero, MathOperatorsHelper.AdditionOperation<UInt, UInt, UInt>(MaxValue, One));
-		}
-		[Fact]
-		public static void op_CheckedAdditionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(Zero, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(One, One));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedAdditionOperation<UInt, UInt, UInt>(MaxValue, 1));
-		}
-		[Fact]	
-		public static void op_IncrementTest()
-		{
-			MathOperatorsHelper.IncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.IncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusTwo).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.IncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-			MathOperatorsHelper.IncrementOperation(MaxValue).Should().Be(Zero);
-		}
-		[Fact]	
-		public static void op_CheckedIncrementTest()
-		{
-			MathOperatorsHelper.CheckedIncrementOperation(Zero).Should().Be(One);
-			MathOperatorsHelper.CheckedIncrementOperation(One).Should().Be(Two);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusTwo).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.CheckedIncrementOperation(MaxValueMinusOne).Should().Be(MaxValue);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedIncrementOperation(MaxValue));
-		}
-		[Fact]
-		public static void op_SubtractionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.SubtractionOperation<UInt, UInt, UInt>(Two, One));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.SubtractionOperation<UInt, UInt, UInt>(MaxValue, 1));
-		}
-		[Fact]
-		public static void op_CheckedSubtractionTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(Two, One));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(MaxValue, 1));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedSubtractionOperation<UInt, UInt, UInt>(Zero, 1));
-		}
-		[Fact]
-		public static void op_DecrementTest()
-		{
-			MathOperatorsHelper.DecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.DecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.DecrementOperation(MaxValueMinusOne).Should().Be(MaxValueMinusTwo);
-			MathOperatorsHelper.DecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-			MathOperatorsHelper.DecrementOperation(Zero).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_CheckedDecrementTest()
-		{
-			MathOperatorsHelper.CheckedDecrementOperation(Two).Should().Be(One);
-			MathOperatorsHelper.CheckedDecrementOperation(One).Should().Be(Zero);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValueMinusOne).Should().Be(MaxValueMinusTwo);
-			MathOperatorsHelper.CheckedDecrementOperation(MaxValue).Should().Be(MaxValueMinusOne);
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedDecrementOperation(Zero));
-		}
-		[Fact]
-		public static void op_MultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.MultiplicationOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.MultiplicationOperation<UInt, UInt, UInt>(Two, One));
-			Assert.Equal(MaxValueMinusOne, MathOperatorsHelper.MultiplicationOperation<UInt, UInt, UInt>(Two, HalfMaxValue));
-		}
-		[Fact]
-		public static void op_CheckedMultiplyTest()
-		{
-			Assert.Equal(One, MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(One, One));
-			Assert.Equal(Two, MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(Two, One));
-
-			Assert.Throws<OverflowException>(() => MathOperatorsHelper.CheckedMultiplicationOperation<UInt, UInt, UInt>(MaxValue, Two));
-		}
-		[Fact]
-		public static void op_DivisionTest()
-		{
-			Assert.Equal(
-				  HalfMaxValue,
-				  MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, Two));
-			Assert.Equal(
-				  new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					  0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF),
-				  MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(
-					  UInt256.MaxValue, 
-					  Two));
-			Assert.Equal(
-				  new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					  0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF),
-				  MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(
-					  UInt128.MaxValue, 
-					  Two));
-			
-			Assert.Equal(
-				  new(0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F,
-				  0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28),
-				  MaxValue / 100);
-			Assert.Equal(
-				  new(0x0006_8DB8_BAC7_10CB, 0x295E_9E1B_089A_0275, 0x2546_0AA6_4C2F_837B, 0x4A23_39C0_EBED_FA43,
-				  0xFE5C_91D1_4E3B_CD35, 0xA858_793D_D97F_62B6, 0xAE7D_566C_F41F_212D, 0x7731_8FC5_0481_6F00),
-				  (MaxValue / 100) / 100);
-			Assert.Equal(
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01, 
-				0x53B6_2BE7_BC1A_0042, 0xB443_E18A_C4E7_0AFD, 0xB897_7684_D802_7110, 0x5B47_424E_B16F_CC18), 
-				MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, E40));
-			Assert.Equal(
-				new UInt(
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x1DA4_8CE4_68E7_C702, 0x6520_247D_3556_476D, 0x1469_CAF6_DB22_4CF9, 0x7D7D_B189_5F2A_4679
-				), 
-				MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(new UInt(
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01,
-				0x53B6_2BE7_BC1A_0042, 0xB443_E18A_C4E7_0AFD, 0xB897_7684_D802_7110, 0x5B47_424E_B16F_CC18
-					), 
-					new UInt(
-						0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x4B3B_4CA8_5A86_C47A, 0x098A_2240_0000_0000
-						)));
-			Assert.Equal(One, MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(MaxValue, MaxValue));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.DivisionOperation<UInt, UInt, UInt>(One, Zero));
-		}
-		[Fact]
-		public static void op_CheckedDivisionTest()
-		{
-			Assert.Equal(
-				  HalfMaxValue,
-				  MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, Two));
-			Assert.Equal(One, MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, MaxValue));
-			Assert.Equal(
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01,
-				0x53B6_2BE7_BC1A_0042, 0xB443_E18A_C4E7_0AFD, 0xB897_7684_D802_7110, 0x5B47_424E_B16F_CC18),
-				MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(MaxValue, E40));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.CheckedDivisionOperation<UInt, UInt, UInt>(One, Zero));
-		}
-		[Fact]
-		public static void op_ModulusTest()
-		{
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(Two, Two).Should().Be(Zero);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(One, Two).Should().NotBe(Zero);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(MaxValue, new(10U)).Should().Be(5U);
-			MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(MaxValue, E40)
-				.Should().Be(
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0011, 0xC828_0B1A_5E03_5840, 0xF8B2_E7FF_FFFF_FFFF));
-
-			Assert.Throws<DivideByZeroException>(() => MathOperatorsHelper.ModulusOperation<UInt, UInt, UInt>(One, Zero));
-		}
-
-		[Fact]
-		public static void op_BitwiseAndTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(Zero, 1U).Should().Be(Zero);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(One, 1U).Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseAndOperation(MaxValue, 1U).Should().Be(One);
-		}
-		[Fact]
-		public static void op_BitwiseOrTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(One, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.BitwiseOrOperation(MaxValue, 1U)
-				.Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void op_ExclusiveOrTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(Zero, 1U)
-				.Should().Be(One);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(One, 1U)
-				.Should().Be(Zero);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.ExclusiveOrOperation(MaxValue, 1U)
-				.Should().Be(MaxValueMinusOne);
-		}
-		[Fact]
-		public static void op_OnesComplementTest()
-		{
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(Zero)
-				.Should().Be(MaxValue);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(One)
-				.Should().Be(MaxValueMinusOne);
-			BitwiseOperatorsHelper<UInt, UInt, UInt>.OnesComplementOperation(MaxValue)
-				.Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void op_LeftShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(One, 1)
-				.Should().Be(Two);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(MaxValue, 1)
-				.Should().Be(MaxValueMinusOne);
-
-			UInt actual = new(
-				0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 
-				0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64)
-				.Should().Be(new(
-					0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 
-				0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 2)
-				.Should().Be(new(
-					0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C,
-				 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 3)
-				.Should().Be(new(
-					0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2,
-				  0x8F5C_28F5_C28F_5C28, 0, 0, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 4)
-				.Should().Be(new(
-					0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28,
-				  0, 0, 0, 0 ));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 5)
-				.Should().Be(new(
-					0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0,
-				  0, 0, 0, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 6)
-				.Should().Be(new(
-					0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0, 0,
-				  0, 0, 0, 0));
-			ShiftOperatorsHelper<UInt, int, UInt>.LeftShiftOperation(actual, 64 * 7)
-				.Should().Be(new(
-					0x8F5C_28F5_C28F_5C28, 0, 0, 0,
-				  0, 0, 0, 0));
-		}
-		[Fact]
-		public static void op_RightShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(MaxValue, 1)
-				.Should().Be(HalfMaxValue);
-
-			UInt actual = new(
-				0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F,
-				0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 1)
-				.Should().Be(new(
-					0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28,
-					0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 2)
-				.Should().Be(new(
-					0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 
-					0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 3)
-				.Should().Be(new(
-					0, 0, 0, 0x028F_5C28_F5C2_8F5C, 
-					0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 4)
-				.Should().Be(new(
-					0, 0, 0, 0, 
-					0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 5)
-				.Should().Be(new(
-					0, 0, 0, 0, 
-					0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 6)
-				.Should().Be(new(
-					0, 0, 0, 0, 
-					0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.RightShiftOperation(actual, 64 * 7)
-				.Should().Be(new(
-					0, 0, 0, 0, 
-					0, 0, 0, 0x028F_5C28_F5C2_8F5C));
-		}
-		[Fact]
-		public static void op_UnsignedRightShiftTest()
-		{
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(Zero, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(One, 1)
-				.Should().Be(Zero);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(MaxValue, 1)
-				.Should().Be(HalfMaxValue);
-
-			UInt actual = new(
-				0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F,
-				0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28);
-
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 0)
-				.Should().Be(actual);
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 1)
-				.Should().Be(new(
-					0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28,
-					0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 2)
-				.Should().Be(new(
-					0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2,
-					0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5, 0xC28F_5C28_F5C2_8F5C));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 3)
-				.Should().Be(new(
-					0, 0, 0, 0x028F_5C28_F5C2_8F5C,
-					0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F, 0x5C28_F5C2_8F5C_28F5));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 4)
-				.Should().Be(new(
-					0, 0, 0, 0,
-					0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28, 0xF5C2_8F5C_28F5_C28F));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 5)
-				.Should().Be(new(
-					0, 0, 0, 0,
-					0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2, 0x8F5C_28F5_C28F_5C28));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 6)
-				.Should().Be(new(
-					0, 0, 0, 0,
-					0, 0, 0x028F_5C28_F5C2_8F5C, 0x28F5_C28F_5C28_F5C2));
-			ShiftOperatorsHelper<UInt, int, UInt>.UnsignedRightShiftOperation(actual, 64 * 7)
-				.Should().Be(new(
-					0, 0, 0, 0,
-					0, 0, 0, 0x028F_5C28_F5C2_8F5C));
-		}
-
-		[Fact]
-		public static void op_EqualityTest()
-		{
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(Zero, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(One, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<UInt, UInt, bool>.EqualityOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_InequalityTest()
-		{
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(Zero, 1U).Should().BeTrue();
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(One, 1U).Should().BeFalse();
-			EqualityOperatorsHelper<UInt, UInt, bool>.InequalityOperation(MaxValue, 1U).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void op_GreaterThanTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(MaxValue, 1U).Should().BeTrue();
-
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(
-				new(0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1), new(0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1))
-				.Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(
-				new(0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1), new(0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0))
-				.Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOperation(
-				new(0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1), new(0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1, 0x1))
-				.Should().BeTrue();
-		}
-		[Fact]
-		public static void op_GreaterThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(Zero, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.GreaterThanOrEqualOperation(MaxValue, 1U).Should().BeTrue();
-		}
-		[Fact]
-		public static void op_LessThanTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(One, 1U).Should().BeFalse();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		[Fact]
-		public static void op_LessThanOrEqualTest()
-		{
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(Zero, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(One, 1U).Should().BeTrue();
-			ComparisonOperatorsHelper<UInt, UInt, bool>.LessThanOrEqualOperation(MaxValue, 1U).Should().BeFalse();
-		}
-		#endregion
-
-		#region Identities
-		[Fact]
-		public static void AdditiveIdentityTest()
-		{
-			Assert.Equal(Zero, MathConstantsHelper.AdditiveIdentityHelper<UInt, UInt>());
-		}
-
-		[Fact]
-		public static void MultiplicativeIdentityTest()
-		{
-			Assert.Equal(One, MathConstantsHelper.MultiplicativeIdentityHelper<UInt, UInt>());
-		}
-		#endregion
-
-		#region IBinaryInteger
-		[Fact]
-		public static void DivRemTest()
-		{
-			Assert.Equal((Zero, Zero), BinaryIntegerHelper<UInt>.DivRem(Zero, Two));
-			Assert.Equal((Zero, One), BinaryIntegerHelper<UInt>.DivRem(One, Two));
-			Assert.Equal((HalfMaxValue, One), BinaryIntegerHelper<UInt>.DivRem(MaxValue, 2));
-			Assert.Equal((
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x08B6_1313_BBAB_CE2C, 0x6232_3AC4_B3B3_DA01,
-				0x53B6_2BE7_BC1A_0042, 0xB443_E18A_C4E7_0AFD, 0xB897_7684_D802_7110, 0x5B47_424E_B16F_CC18),
-				new UInt(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0011, 0xC828_0B1A_5E03_5840, 0xF8B2_E7FF_FFFF_FFFF)),
-				BinaryIntegerHelper<UInt>.DivRem(MaxValue, E40));
-		}
-
-		[Fact]
-		public static void LeadingZeroCountTest()
-		{
-			Assert.Equal(512U, BinaryIntegerHelper<UInt>.LeadingZeroCount(Zero));
-			Assert.Equal(511U, BinaryIntegerHelper<UInt>.LeadingZeroCount(One));
-			Assert.Equal(448U, BinaryIntegerHelper<UInt>.LeadingZeroCount(ulong.MaxValue));
-			Assert.Equal(384U, BinaryIntegerHelper<UInt>.LeadingZeroCount(UInt128.MaxValue));
-			Assert.Equal(256U, BinaryIntegerHelper<UInt>.LeadingZeroCount(UInt256.MaxValue));
-			Assert.Equal(192U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue >>> 192));
-			Assert.Equal(128U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue >>> 128));
-			Assert.Equal(64U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue >>> 64));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.LeadingZeroCount(MaxValue));
-		}
-
-		[Fact]
-		public static void PopCountTest()
-		{
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.PopCount(Zero));
-			Assert.Equal(1U, BinaryIntegerHelper<UInt>.PopCount(One));
-			Assert.Equal(512U, BinaryIntegerHelper<UInt>.PopCount(MaxValue));
-		}
-
-		[Fact]
-		public static void RotateLeftTest()
-		{
-			Assert.Equal(Zero, BinaryIntegerHelper<UInt>.RotateLeft(Zero, 1));
-			Assert.Equal(Two, BinaryIntegerHelper<UInt>.RotateLeft(One, 1));
-			Assert.Equal(MaxValue, BinaryIntegerHelper<UInt>.RotateLeft(MaxValue, 1));
-		}
-
-		[Fact]
-		public static void RotateRightTest()
-		{
-			Assert.Equal(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<UInt>.RotateRight(Zero, 1));
-			Assert.Equal(new(
-				  0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				  0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), BinaryIntegerHelper<UInt>.RotateRight(One, 1));
-			Assert.Equal(new(
-				  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
-				  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), BinaryIntegerHelper<UInt>.RotateRight(MaxValue, 1));
-		}
-
-		[Fact]
-		public static void TrailingZeroCountTest()
-		{
-			Assert.Equal(512U, BinaryIntegerHelper<UInt>.TrailingZeroCount(Zero));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.TrailingZeroCount(One));
-			Assert.Equal(64U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 0, 0, 0, 0, 0, 1, 0)));
-			Assert.Equal(128U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 0, 0, 0, 0, 1, 0, 0)));
-			Assert.Equal(192U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 0, 0, 0, 1, 0, 0, 0)));
-			Assert.Equal(256U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 0, 0, 1, 0, 0, 0, 0)));
-			Assert.Equal(320U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 0, 1, 0, 0, 0, 0, 0)));
-			Assert.Equal(384U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(0, 1, 0, 0, 0, 0, 0, 0)));
-			Assert.Equal(448U, BinaryIntegerHelper<UInt>.TrailingZeroCount(new UInt(1, 0, 0, 0, 0, 0, 0, 0)));
-			Assert.Equal(0U, BinaryIntegerHelper<UInt>.TrailingZeroCount(MaxValue));
-		}
-		[Fact]
-		public static void TryReadLittleEndianInt256Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: false, out result));
-			Assert.Equal(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: false, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-		}
-
-		[Fact]
-		public static void TryReadLittleEndianUInt256Test()
-		{
-			UInt result;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0100_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF7F), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, isUnsigned: true, out result));
-			Assert.Equal(new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0080), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, isUnsigned: true, out result));
-			Assert.Equal(new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryReadLittleEndian(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, isUnsigned: true, out result));
-			Assert.Equal(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), result);
-		}
-
-		[Fact]
-		public static void GetByteCountTest()
-		{
-			Assert.Equal(64, BinaryIntegerHelper<UInt>.GetByteCount(Zero));
-			Assert.Equal(64, BinaryIntegerHelper<UInt>.GetByteCount(One));
-			Assert.Equal(64, BinaryIntegerHelper<UInt>.GetByteCount(MaxValue));
-		}
-
-		[Fact]
-		public static void GetShortestBitLengthTest()
-		{
-			Assert.Equal(0x00, BinaryIntegerHelper<UInt>.GetShortestBitLength(Zero));
-			Assert.Equal(0x01, BinaryIntegerHelper<UInt>.GetShortestBitLength(One));
-			Assert.Equal(0x200, BinaryIntegerHelper<UInt>.GetShortestBitLength(MaxValue));
-		}
-
-		[Fact]
-		public static void TryWriteBigEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[64];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(One, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteBigEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryWriteBigEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-
-		[Fact]
-		public static void TryWriteLittleEndianTest()
-		{
-			Span<byte> destination = stackalloc byte[64];
-			int bytesWritten = 0;
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(Zero, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(One, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, destination.ToArray());
-
-			Assert.True(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(MaxValue, destination, out bytesWritten));
-			Assert.Equal(64, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-
-			Assert.False(BinaryIntegerHelper<UInt>.TryWriteLittleEndian(default, Span<byte>.Empty, out bytesWritten));
-			Assert.Equal(0, bytesWritten);
-			Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, destination.ToArray());
-		}
-		#endregion
-
-		#region IBinaryNumber
-		[Fact]
-		public static void AllBitsSetTest()
-		{
-			Assert.Equal(BinaryNumberHelper<UInt>.AllBitsSet, ~Zero);
-		}
-		[Fact]
-		public static void IsPow2Test()
-		{
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x100)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x1_0000)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(0x1_0000_0000)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000)));
-			Assert.True(BinaryNumberHelper<UInt>.IsPow2(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-		}
-		[Fact]
-		public static void Log2Test()
-		{
-			Assert.Equal(8U, BinaryNumberHelper<UInt>.Log2(new(0x100)));
-			Assert.Equal(16U, BinaryNumberHelper<UInt>.Log2(new(0x1_0000)));
-			Assert.Equal(32U, BinaryNumberHelper<UInt>.Log2(new(0x1_0000_0000)));
-			Assert.Equal(64U, BinaryNumberHelper<UInt>.Log2(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000)));
-			Assert.Equal(128U, BinaryNumberHelper<UInt>.Log2(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-			Assert.Equal(256U, BinaryNumberHelper<UInt>.Log2(new(
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001,
-				0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)));
-		}
-		#endregion
-
-		#region IMinMaxValue
-		[Fact]
-		public static void MaxValueTest()
-		{
-			MaxValue.Should().Be(MathConstantsHelper.MaxValue<UInt>());
-		}
-
-		[Fact]
-		public static void MinValueTest()
-		{
-			Zero.Should().Be(MathConstantsHelper.MinValue<UInt>());
-		}
-		#endregion
-
-		#region INumber
-		[Fact]
-		public static void ClampTest()
-		{
-			NumberHelper<UInt>.Clamp(MaxValueMinusOne, UInt128MaxValue, MaxValue).Should().Be(MaxValueMinusOne);
-			NumberHelper<UInt>.Clamp(Zero, Two, MaxValue).Should().Be(Two);
-			NumberHelper<UInt>.Clamp(MaxValue, Zero, One).Should().Be(One);
-
-			Assert.Throws<ArgumentException>(() => NumberHelper<UInt>.Clamp(Zero, MaxValue, Zero));
-		}
-		[Fact]
-		public static void CopySignTest()
-		{
-			NumberHelper<UInt>.CopySign(MaxValue, One).Should().Be(MaxValue);
-		}
-		[Fact]
-		public static void MaxTest()
-		{
-			NumberHelper<UInt>.Max(MaxValue, Two).Should().Be(MaxValue);
-			NumberHelper<UInt>.Max(One, Zero).Should().Be(One);
-			NumberHelper<UInt>.Max(Two, Zero).Should().Be(Two);
-			NumberHelper<UInt>.Max(Two, One).Should().Be(Two);
-		}
-		[Fact]
-		public static void MaxNumberTest()
-		{
-			NumberHelper<UInt>.MaxNumber(MaxValue, Zero).Should().Be(MaxValue);
-			NumberHelper<UInt>.MaxNumber(One, Zero).Should().Be(One);
-			NumberHelper<UInt>.MaxNumber(Two, Zero).Should().Be(Two);
-		}
-		[Fact]
-		public static void MinTest()
-		{
-			NumberHelper<UInt>.Min(MaxValue, Zero).Should().Be(Zero);
-			NumberHelper<UInt>.Min(One,	Zero).Should().Be(Zero);
-			NumberHelper<UInt>.Min(Two, Zero).Should().Be(Zero);
-		}
-		[Fact]
-		public static void MinNumberTest()
-		{
-			NumberHelper<UInt>.MinNumber(MaxValue, Zero).Should().Be(Zero);
-			NumberHelper<UInt>.MinNumber(One,Zero).Should().Be(Zero);
-			NumberHelper<UInt>.MinNumber(Two, Zero).Should().Be(Zero);
-		}
-		[Fact]
-		public static void SignTest()
-		{
-			NumberHelper<UInt>.Sign(MaxValue).Should().Be(1);
-			NumberHelper<UInt>.Sign(UInt.Zero).Should().Be(0);
-		}
-		#endregion
-
-		#region INumberBase
-		[Fact]
-		public static void AbsTest()
-		{
-			NumberBaseHelper<UInt>.Abs(One).Should().Be(One);
-		}
-		[Fact]
-		public static void CreateCheckedToUInt512Test()
-		{
-			NumberBaseHelper<UInt>.CreateChecked(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(UInt256.MaxValue).Should().Be(UInt256MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateChecked(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateChecked(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateChecked(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(UInt128.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateChecked(UInt256.MinValue).Should().Be(Zero);
-		}
-		[Fact]
-		public static void CreateSaturatingToUInt512Test()
-		{
-			NumberBaseHelper<UInt>.CreateSaturating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt256.MaxValue).Should().Be(UInt256MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateSaturating(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateSaturating(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateSaturating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt128.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateSaturating(UInt256.MinValue).Should().Be(Zero);
-		}
-		[Fact]
-		public static void CreateTruncatingToUInt512Test()
-		{
-			NumberBaseHelper<UInt>.CreateTruncating(byte.MaxValue).Should().Be(ByteMaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(ushort.MaxValue).Should().Be(UInt16MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(uint.MaxValue).Should().Be(UInt32MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(ulong.MaxValue).Should().Be(UInt64MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt128.MaxValue).Should().Be(UInt128MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt256.MaxValue).Should().Be(UInt256MaxValue);
-			NumberBaseHelper<UInt>
-				.CreateTruncating(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"))
-				.Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.CreateTruncating(MaxValueAsDouble).Should().Be(MaxValue);
-
-			NumberBaseHelper<UInt>.CreateTruncating(byte.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(ushort.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(uint.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(ulong.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt128.MinValue).Should().Be(Zero);
-			NumberBaseHelper<UInt>.CreateTruncating(UInt256.MinValue).Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void CreateCheckedFromUInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateChecked(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateChecked(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateChecked(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateChecked(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateChecked(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateChecked(UInt256MaxValue).Should().Be(UInt256.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateChecked(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
-			NumberBaseHelper<double>.CreateChecked(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateChecked(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateChecked(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateChecked(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateChecked(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateChecked(Zero).Should().Be(UInt128.MinValue);
-			NumberBaseHelper<UInt256>.CreateChecked(Zero).Should().Be(UInt256.MinValue);
-		}
-		[Fact]
-		public static void CreateSaturatingFromUInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateSaturating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateSaturating(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateSaturating(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateSaturating(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateSaturating(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateSaturating(UInt256MaxValue).Should().Be(UInt256.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateSaturating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
-			NumberBaseHelper<double>.CreateSaturating(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateSaturating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateSaturating(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateSaturating(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateSaturating(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateSaturating(Zero).Should().Be(UInt128.MinValue);
-			NumberBaseHelper<UInt256>.CreateSaturating(Zero).Should().Be(UInt256.MinValue);
-		}
-		[Fact]
-		public static void CreateTruncatingFromUInt512Test()
-		{
-			NumberBaseHelper<byte>.CreateTruncating(ByteMaxValue).Should().Be(byte.MaxValue);
-			NumberBaseHelper<ushort>.CreateTruncating(UInt16MaxValue).Should().Be(ushort.MaxValue);
-			NumberBaseHelper<uint>.CreateTruncating(UInt32MaxValue).Should().Be(uint.MaxValue);
-			NumberBaseHelper<ulong>.CreateTruncating(UInt64MaxValue).Should().Be(ulong.MaxValue);
-			NumberBaseHelper<UInt128>.CreateTruncating(UInt128MaxValue).Should().Be(UInt128.MaxValue);
-			NumberBaseHelper<UInt256>.CreateTruncating(UInt256MaxValue).Should().Be(UInt256.MaxValue);
-			NumberBaseHelper<BigInteger>.CreateTruncating(MaxValue).Should()
-				.Be(BigInteger.Parse(
-					"13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
-			NumberBaseHelper<double>.CreateTruncating(MaxValue).Should().Be(MaxValueAsDouble);
-
-			NumberBaseHelper<byte>.CreateTruncating(Zero).Should().Be(byte.MinValue);
-			NumberBaseHelper<ushort>.CreateTruncating(Zero).Should().Be(ushort.MinValue);
-			NumberBaseHelper<uint>.CreateTruncating(Zero).Should().Be(uint.MinValue);
-			NumberBaseHelper<ulong>.CreateTruncating(Zero).Should().Be(ulong.MinValue);
-			NumberBaseHelper<UInt128>.CreateTruncating(Zero).Should().Be(UInt128.MinValue);
-			NumberBaseHelper<UInt256>.CreateTruncating(Zero).Should().Be(UInt256.MinValue);
-		}
-
-		[Fact]
-		public static void IsCanonicalTest()
-		{
-			NumberBaseHelper<UInt>.IsCanonical(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsComplexNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsComplexNumber(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsEvenIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsEvenInteger(One).Should().BeFalse();
-			NumberBaseHelper<UInt>.IsEvenInteger(Two).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsFiniteTest()
-		{
-			NumberBaseHelper<UInt>.IsFinite(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsImaginaryNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsImaginaryNumber(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsInfinity(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsInteger(default(UInt)).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsNaNTest()
-		{
-			NumberBaseHelper<UInt>.IsNaN(default(UInt)).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeTest()
-		{
-			NumberBaseHelper<UInt>.IsNegative(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNegativeInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsNegativeInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsNormalTest()
-		{
-			NumberBaseHelper<UInt>.IsNormal(Zero).Should().BeFalse();
-			NumberBaseHelper<UInt>.IsNormal(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsOddIntegerTest()
-		{
-			NumberBaseHelper<UInt>.IsOddInteger(One).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsOddInteger(Two).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsPositiveTest()
-		{
-			NumberBaseHelper<UInt>.IsPositive(One).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsPositiveInfinityTest()
-		{
-			NumberBaseHelper<UInt>.IsPositiveInfinity(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsRealNumberTest()
-		{
-			NumberBaseHelper<UInt>.IsRealNumber(default).Should().BeTrue();
-		}
-
-		[Fact]
-		public static void IsSubnormalTest()
-		{
-			NumberBaseHelper<UInt>.IsSubnormal(default).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void IsZeroTest()
-		{
-			NumberBaseHelper<UInt>.IsZero(default).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsZero(Zero).Should().BeTrue();
-			NumberBaseHelper<UInt>.IsZero(One).Should().BeFalse();
-		}
-
-		[Fact]
-		public static void MaxMagnitudeTest()
-		{
-			NumberBaseHelper<UInt>.MaxMagnitude(MaxValue, Zero).Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.MaxMagnitude(One, Zero).Should().Be(One);
-			NumberBaseHelper<UInt>.MaxMagnitude(Two, Zero).Should().Be(Two);
-		}
-
-		[Fact]
-		public static void MaxMagnitudeNumberTest()
-		{
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(MaxValue, Zero).Should().Be(MaxValue);
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(One, Zero).Should().Be(One);
-			NumberBaseHelper<UInt>.MaxMagnitudeNumber(Two, Zero).Should().Be(Two);
-		}
-
-		[Fact]
-		public static void MinMagnitudeTest()
-		{
-			NumberBaseHelper<UInt>.MinMagnitude(MaxValue, MaxValueMinusOne).Should().Be(MaxValueMinusOne);
-			NumberBaseHelper<UInt>.MinMagnitude(One, Zero).Should().Be(Zero);
-			NumberBaseHelper<UInt>.MinMagnitude(Two, Zero).Should().Be(Zero);
-		}
-
-		[Fact]
-		public static void MinMagnitudeNumberTest()
-		{
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(MaxValue, MaxValueMinusOne).Should().Be(MaxValueMinusOne);
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(One, Zero).Should().Be(Zero);
-			NumberBaseHelper<UInt>.MinMagnitudeNumber(Two, Zero).Should().Be(Zero);
-		}
-
-		[Fact]
-		public void ParseTest()
-		{
-			NumberBaseHelper<UInt>.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse(MaxValueBin, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<UInt>.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseTest()
-		{
-			NumberBaseHelper<UInt>.TryParse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out UInt parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse(MaxValueBin, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.TryParse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096", System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-
-		[Fact]
-		public void ParseUtf8Test()
-		{
-			NumberBaseHelper<UInt>.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.Parse(MaxValueBinUtf8, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture)
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			Assert.Throws<OverflowException>(() => NumberBaseHelper<UInt>.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture));
-		}
-
-		[Fact]
-		public void TryParseUtf8Test()
-		{
-			NumberBaseHelper<UInt>.TryParse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out UInt parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8, System.Globalization.NumberStyles.HexNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-			NumberBaseHelper<UInt>.TryParse(MaxValueBinUtf8, System.Globalization.NumberStyles.BinaryNumber, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-
-			NumberBaseHelper<UInt>.TryParse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"u8, System.Globalization.NumberStyles.Integer, CultureInfo.CurrentCulture, out parsedValue)
-				.Should().BeFalse();
-			parsedValue.Should().Be(default);
-		}
-		#endregion
-
-		#region IPowerFunctions
-		[Fact]
-		public void PowTest()
-		{
-			GenericFloatingPointFunctions.Pow(Zero, (uint)int.MaxValue).Should().Be(Zero);
-			GenericFloatingPointFunctions.Pow(One, (uint)int.MaxValue).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, Zero).Should().Be(One);
-			GenericFloatingPointFunctions.Pow(MaxValue, One).Should().Be(MaxValue);
-			GenericFloatingPointFunctions.Pow(Two, Two).Should().Be(4);
-			GenericFloatingPointFunctions.Pow(Two, 4U).Should().Be(16);
-			GenericFloatingPointFunctions.Pow(16U, Two).Should().Be(256);
-			GenericFloatingPointFunctions.Pow(Two, 511U)
-				.Should().Be(new UInt(
-					0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
-					0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
-
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two, 512U));
-			Assert.Throws<OverflowException>(() => GenericFloatingPointFunctions.Pow(Two + Two, 511U));
-		}
-		#endregion
-	}
-}
diff --git a/src/MissingValues.Tests/Core/UInt512Test.cs b/src/MissingValues.Tests/Core/UInt512Test.cs
deleted file mode 100644
index f1f8110..0000000
--- a/src/MissingValues.Tests/Core/UInt512Test.cs
+++ /dev/null
@@ -1,259 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Text.Json;
-using System.Text.Unicode;
-using System.Threading.Tasks;
-
-using UInt = MissingValues.UInt512;
-
-namespace MissingValues.Tests.Core
-{
-	public partial class UInt512Test
-	{
-		[Fact]
-		public void Cast_ToByte()
-		{
-			byte.MinValue.Should().Be((byte)Zero);
-			byte.MaxValue.Should().Be((byte)ByteMaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt16()
-		{
-			ushort.MinValue.Should().Be((ushort)Zero);
-			ushort.MaxValue.Should().Be((ushort)UInt16MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt32()
-		{
-			uint.MinValue.Should().Be((uint)Zero);
-			uint.MaxValue.Should().Be((uint)UInt32MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt64()
-		{
-			ulong.MinValue.Should().Be((ulong)Zero);
-			ulong.MaxValue.Should().Be((ulong)UInt64MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt128()
-		{
-			UInt128.MinValue.Should().Be((UInt128)Zero);
-			UInt128.MaxValue.Should().Be((UInt128)UInt128MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToUInt256()
-		{
-			UInt256.MinValue.Should().Be((UInt256)Zero);
-			UInt256.MaxValue.Should().Be((UInt256)UInt256MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToBigInteger()
-		{
-			BigInteger.One.Should().Be((BigInteger)One);
-			BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095")
-				.Should().Be((BigInteger)MaxValue);
-		}
-
-		[Fact]
-		public void Cast_ToDouble()
-		{
-			// Test a UInt256Converter value where _upper is 0
-			UInt value1 = new UInt(UInt256.MaxValue);
-			double exp1 = System.Math.Round((double)UInt256.MaxValue, 5);
-			double act1 = System.Math.Round((double)value1, 5);
-			double diff1 = System.Math.Abs(exp1 * 0.00000000001);
-			Assert.True(System.Math.Abs(exp1 - act1) <= diff1);
-
-
-			// Test a UInt256Converter value where _upper is not 0
-			UInt value2 = new UInt(UInt256.MaxValue, UInt256.MaxValue);
-			double exp2 = System.Math.Round(((double)UInt256.MaxValue) * System.Math.Pow(2.0, 256), 5);
-			double act2 = System.Math.Round((double)value2, 5);
-			double diff2 = System.Math.Abs(exp2 * 0.00000000001);
-			Assert.True(System.Math.Abs(exp2 - act2) <= diff2);
-		}
-
-		[Fact]
-		public void BigMulTest()
-		{
-			UInt upper = UInt.BigMul(MaxValue, Two, out UInt lower);
-
-			upper
-				.Should()
-				.Be(new(0x1));
-			lower
-				.Should()
-				.Be(new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
-		}
-		
-		[Fact]
-		public void Internal_DivRemTest()
-		{
-			const long Left = 101_000_000_000;
-			const long Right = 10_000_000_000;
-			const long Quotient = 10;
-			const long Remainder = 1_000_000_000;
-
-			UInt a = Left;
-			UInt b = Right;
-
-			UInt.DivRem(in a, in b, out UInt quotient, out UInt remainder);
-
-			quotient.Should().Be(Quotient);
-			remainder.Should().Be(Remainder);
-
-			UInt.DivRem(in a, in b, out a, out remainder);
-
-			a.Should().Be(Quotient);
-			remainder.Should().Be(Remainder);
-
-			UInt.DivRem(Left, in b, out quotient, out b);
-
-			quotient.Should().Be(Quotient);
-			b.Should().Be(Remainder);
-		}
-
-		[Fact]
-		public void BasicParseTest()
-		{
-			UInt.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095")
-				.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-		}
-
-		[Fact]
-		public void BasicTryParseTest()
-		{
-			UInt.TryParse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095", out UInt parsedValue).Should().BeTrue();
-			parsedValue.Should().Be(MaxValue)
-				.And.BeRankedEquallyTo(MaxValue);
-		}
-
-		[Fact]
-		public void ToDecStringTest()
-		{
-			Zero.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("0");
-			MaxValue.ToString("D", CultureInfo.CurrentCulture)
-				.Should().Be("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095");
-		}
-		[Fact]
-		public void ToHexStringTest()
-		{
-			One.ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((UInt)byte.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FF");
-			((UInt)ushort.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFF");
-			((UInt)uint.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFF");
-			((UInt)ulong.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFF");
-			((UInt)UInt128.MaxValue).ToString("X", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-
-			Zero.ToString("X128", CultureInfo.CurrentCulture)
-				.Should().Be("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("x128", CultureInfo.CurrentCulture)
-				.Should().Be("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-			MaxValue.ToString("X128", CultureInfo.CurrentCulture)
-				.Should().Be("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-		}
-		[Fact]
-		public void ToBinStringTest()
-		{
-			One.ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1");
-			((UInt)byte.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111");
-			((UInt)ushort.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111");
-			((UInt)uint.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111111111111111111111111111");
-			((UInt)ulong.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("1111111111111111111111111111111111111111111111111111111111111111");
-			((UInt)UInt128.MaxValue).ToString("B", CultureInfo.CurrentCulture)
-				.Should().Be("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-
-			Zero.ToString("B512", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-			MaxValue.ToString("B512", CultureInfo.CurrentCulture)
-				.Should()
-				.Be("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
-		}
-
-		[Fact]
-		public void ToDecFormatStringTest()
-		{
-			MaxValue.ToString().Should().Be($"{MaxValue:D}");
-		}
-		[Fact]
-		public void ToHexFormatStringTest()
-		{
-			MaxValue.ToString("X128", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:X128}");
-		}
-		[Fact]
-		public void ToBinFormatStringTest()
-		{
-			MaxValue.ToString("B512", CultureInfo.CurrentCulture).Should().Be($"{MaxValue:B512}");
-		}
-
-		[Fact]
-		public void ToDecFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString()!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:D}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToHexFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("X128", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:X128}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-		[Fact]
-		public void ToBinFormatUtf8StringTest()
-		{
-			ReadOnlySpan<byte> toString = Encoding.UTF8.GetBytes(MaxValue.ToString("B512", CultureInfo.CurrentCulture)!);
-
-			Span<byte> format = stackalloc byte[toString.Length];
-			bool success = Utf8.TryWrite(format, CultureInfo.CurrentCulture, $"{MaxValue:B512}", out _);
-			Assert.Equal(toString, format);
-			success.Should().BeTrue();
-		}
-
-		[Fact]
-		public void JsonWriteTest()
-		{
-			JsonSerializer.Serialize(new object[] { MaxValue, Zero, One })
-				.Should().Be("[13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095,0,1]");
-		}
-		[Fact]
-		public void JsonReadTest()
-		{
-			JsonSerializer.Deserialize<UInt>("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095")
-				.Should().Be(MaxValue);
-			JsonSerializer.Deserialize<UInt>("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"u8)
-				.Should().Be(MaxValue);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Data/CalculatorDataSources.cs b/src/MissingValues.Tests/Data/CalculatorDataSources.cs
new file mode 100644
index 0000000..895e89a
--- /dev/null
+++ b/src/MissingValues.Tests/Data/CalculatorDataSources.cs
@@ -0,0 +1,475 @@
+using MissingValues.Internals;
+
+namespace MissingValues.Tests.Data;
+
+public class CalculatorDataSources
+{
+	public static IEnumerable<Func<(UInt512, int)>> Log10TestData()
+	{
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0000000000000001), 0);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x000000000000000A), 1);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0000000000000064), 2);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00000000000003E8), 3);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0000000000002710), 4);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00000000000186A0), 5);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00000000000F4240), 6);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0000000000989680), 7);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0000000005F5E100), 8);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x000000003B9ACA00), 9);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00000002540BE400), 10);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x000000174876E800), 11);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x000000E8D4A51000), 12);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x000009184E72A000), 13);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00005AF3107A4000), 14);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x00038D7EA4C68000), 15);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x002386F26FC10000), 16);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x016345785D8A0000), 17);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x0DE0B6B3A7640000), 18);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000000, 0x8AC7230489E80000), 19);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000005, 0x6BC75E2D63100000), 20);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000000036, 0x35C9ADC5DEA00000), 21);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x000000000000021E, 0x19E0C9BAB2400000), 22);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x000000000000152D, 0x02C7E14AF6800000), 23);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x000000000000D3C2, 0x1BCECCEDA1000000), 24);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000000084595, 0x161401484A000000), 25);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x000000000052B7D2, 0xDCC80CD2E4000000), 26);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x00000000033B2E3C, 0x9FD0803CE8000000), 27);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x00000000204FCE5E, 0x3E25026110000000), 28);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x00000001431E0FAE, 0x6D7217CAA0000000), 29);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000000C9F2C9CD0, 0x4674EDEA40000000), 30);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000007E37BE2022, 0xC0914B2680000000), 31);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x000004EE2D6D415B, 0x85ACEF8100000000), 32);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0000314DC6448D93, 0x38C15B0A00000000), 33);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0001ED09BEAD87C0, 0x378D8E6400000000), 34);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0013426172C74D82, 0x2B878FE800000000), 35);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x00C097CE7BC90715, 0xB34B9F1000000000), 36);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x0785EE10D5DA46D9, 0x00F436A000000000), 37);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000000, 0x4B3B4CA85A86C47A, 0x098A224000000000), 38);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000002, 0xF050FE938943ACC4, 0x5F65568000000000), 39);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x000000000000001D, 0x6329F1C35CA4BFAB, 0xB9F5610000000000), 40);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000125, 0xDFA371A19E6F7CB5, 0x4395CA0000000000), 41);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000000B7A, 0xBC627050305ADF14, 0xA3D9E40000000000), 42);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00000000000072CB, 0x5BD86321E38CB6CE, 0x6682E80000000000), 43);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000000047BF1, 0x9673DF52E37F2410, 0x011D100000000000), 44);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00000000002CD76F, 0xE086B93CE2F768A0, 0x0B22A00000000000), 45);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x0000000001C06A5E, 0xC5433C60DDAA1640, 0x6F5A400000000000), 46);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00000000118427B3, 0xB4A05BC8A8A4DE84, 0x5986800000000000), 47);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00000000AF298D05, 0x0E4395D69670B12B, 0x7F41000000000000), 48);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00000006D79F8232, 0x8EA3DA61E066EBB2, 0xF88A000000000000), 49);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x000000446C3B15F9, 0x926687D2C40534FD, 0xB564000000000000), 50);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x000002AC3A4EDBBF, 0xB8014E3BA83411E9, 0x15E8000000000000), 51);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00001ABA4714957D, 0x300D0E549208B31A, 0xDB10000000000000), 52);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x00010B46C6CDD6E3, 0xE0828F4DB456FF0C, 0x8EA0000000000000), 53);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x000A70C3C40A64E6, 0xC51999090B65F67D, 0x9240000000000000), 54);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x006867A5A867F103, 0xB2FFFA5A71FBA0E7, 0xB680000000000000), 55);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x04140C78940F6A24, 0xFDFFC78873D4490D, 0x2100000000000000), 56);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+				0x28C87CB5C89A2571, 0xEBFDCB54864ADA83, 0x4A00000000000000), 57);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001,
+				0x97D4DF19D6057673, 0x37E9F14D3EEC8920, 0xE400000000000000), 58);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000000000000F,
+				0xEE50B7025C36A080, 0x2F236D04753D5B48, 0xE800000000000000), 59);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000000000009F,
+				0x4F2726179A224501, 0xD762422C946590D9, 0x1000000000000000), 60);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000639,
+				0x17877CEC0556B212, 0x69D695BDCBF7A87A, 0xA000000000000000), 61);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000003E3A,
+				0xEB4AE1383562F4B8, 0x2261D969F7AC94CA, 0x4000000000000000), 62);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000026E4D,
+				0x30ECCC3215DD8F31, 0x57D27E23ACBDCFE6, 0x8000000000000000), 63);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000184F03,
+				0xE93FF9F4DAA797ED, 0x6E38ED64BF6A1F01, 0x0000000000000000), 64);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000F31627,
+				0x1C7FC3908A8BEF46, 0x4E3945EF7A25360A, 0x0000000000000000), 65);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000000097EDD87,
+				0x1CFDA3A5697758BF, 0x0E3CBB5AC5741C64, 0x0000000000000000), 66);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000005EF4A747,
+				0x21E864761EA97776, 0x8E5F518BB6891BE8, 0x0000000000000000), 67);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000003B58E88C7,
+				0x5313EC9D329EAAA1, 0x8FB92F75215B1710, 0x0000000000000000), 68);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000025179157C9,
+				0x3EC73E23FA32AA4F, 0x9D3BDA934D8EE6A0, 0x0000000000000000), 69);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000172EBAD6DDC,
+				0x73C86D67C5FAA71C, 0x245689C107950240, 0x0000000000000000), 70);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000E7D34C64A9C,
+				0x85D4460DBBCA8719, 0x6B61618A4BD21680, 0x0000000000000000), 71);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000090E40FBEEA1D,
+				0x3A4ABC8955E946FE, 0x31CDCF66F634E100, 0x0000000000000000), 72);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0005A8E89D752524,
+				0x46EB5D5D5B1CC5ED, 0xF20A1A059E10CA00, 0x0000000000000000), 73);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x003899162693736A,
+				0xC531A5A58F1FBB4B, 0x746504382CA7E400, 0x0000000000000000), 74);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0235FADD81C2822B,
+				0xB3F07877973D50F2, 0x8BF22A31BE8EE800, 0x0000000000000000), 75);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x161BCCA7119915B5,
+				0x0764B4ABE8652979, 0x7775A5F171951000, 0x0000000000000000), 76);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xDD15FE86AFFAD912,
+				0x49EF0EB713F39EBE, 0xAA987B6E6FD2A000, 0x0000000000000000), 77);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000008, 0xA2DBF142DFCC7AB6,
+				0xE3569326C7843372, 0xA9F4D2505E3A4000, 0x0000000000000000), 78);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000056, 0x5C976C9CBDFCCB24,
+				0xE161BF83CB2A027A, 0xA3903723AE468000, 0x0000000000000000), 79);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000000000035F, 0x9DEA3E1F6BDFEF70,
+				0xCDD17B25EFA418CA, 0x63A22764CEC10000, 0x0000000000000000), 80);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000000000021BC, 0x2B266D3A36BF5A68,
+				0x0A2ECF7B5C68F7E7, 0xE45589F0138A0000, 0x0000000000000000), 81);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000015159, 0xAF80444623798810,
+				0x65D41AD19C19AF0E, 0xEB576360C3640000, 0x0000000000000000), 82);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000000000D2D80, 0xDB02AABD62BF50A3,
+				0xFA490C301900D695, 0x3169E1C7A1E80000, 0x0000000000000000), 83);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000000083C708, 0x8E1AAB65DB792667,
+				0xC6DA79E0FA0861D3, 0xEE22D1CC53100000, 0x0000000000000000), 84);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000000525C655, 0x8D0AB1FA92BB800D,
+				0xC488C2C9C453D247, 0x4D5C31FB3EA00000, 0x0000000000000000), 85);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000003379BF57, 0x826AF3C9BB530089,
+				0xAD579BE1AB4636C9, 0x0599F3D072400000, 0x0000000000000000), 86);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000202C1796B, 0x182D85E1513E0560,
+				0xC56C16D0B0BE23DA, 0x3803862476800000, 0x0000000000000000), 87);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000141B8EBE2E, 0xF1C73ACD2C6C35C7,
+				0xB638E426E76D6686, 0x30233D6CA1000000, 0x0000000000000000), 88);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000000C913936DD5, 0x71C84C03BC3A19CD,
+				0x1E38E9850A46013D, 0xE160663E4A000000, 0x0000000000000000), 89);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x000007DAC3C24A56, 0x71D2F8255A450203,
+				0x2E391F3266BC0C6A, 0xCDC3FE6EE4000000, 0x0000000000000000), 90);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00004E8BA596E760, 0x723DB17586B2141F,
+				0xCE3B37F803587C2C, 0x09A7F054E8000000, 0x0000000000000000), 91);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0003117477E509C4, 0x7668EE9742F4C93E,
+				0x0E502FB02174D9B8, 0x608F635110000000, 0x0000000000000000), 92);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x001EAE8CAEF261AC, 0xA01951E89D8FDC6C,
+				0x8F21DCE14E908133, 0xC599E12AA0000000, 0x0000000000000000), 93);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0132D17ED577D0BE, 0x40FD3316279E9C3D,
+				0x9752A0CD11A50C05, 0xB802CBAA40000000, 0x0000000000000000), 94);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0BFC2EF456AE276E, 0x89E3FEDD8C321A67,
+				0xE93A4802B0727839, 0x301BF4A680000000, 0x0000000000000000), 95);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x77D9D58B62CD8A51, 0x62E7F4A779F5080F,
+				0x1C46D01AE478B23B, 0xE1178E8100000000, 0x0000000000000000), 96);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000000004, 0xAE825771DC07672D, 0xDD0F8E8AC3925097,
+				0x1AC4210CECB6F656, 0xCAEB910A00000000, 0x0000000000000000), 97);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x000000000000002E, 0xD1176A72984A07CA, 0xA29B916BA3B725E7,
+				0x0BA94A813F259F63, 0xED33AA6400000000, 0x0000000000000000), 98);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x00000000000001D4, 0x2AEA2879F2E44DEA, 0x5A13AE3465277B06,
+				0x749CE90C777839E7, 0x4404A7E800000000, 0x0000000000000000), 99);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000001249, 0xAD2594C37CEB0B27, 0x84C4CE0BF38ACE40,
+				0x8E211A7CAAB24308, 0xA82E8F1000000000, 0x0000000000000000), 100);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x000000000000B6E0, 0xC377CFA2E12E6F8B, 0x2FB00C77836C0E85,
+				0x8D4B08DEAAF69E56, 0x91D196A000000000, 0x0000000000000000), 101);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x00000000000724C7, 0xA2AE1C5CCBD05B6F, 0xDCE07CAB22389137,
+				0x84EE58B2ADA22F61, 0xB22FE24000000000, 0x0000000000000000), 102);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000000476FCC, 0x5ACD1B9FF623925E, 0xA0C4DEAF5635AC2B,
+				0x314F76FAC855D9D0, 0xF5DED68000000000, 0x0000000000000000), 103);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000002CA5DFB, 0x8C03143F9D63B7B2, 0x47B0B2D95E18B9AF,
+				0xED1AA5CBD35A8229, 0x9AB4610000000000, 0x0000000000000000), 104);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x000000001BE7ABD3, 0x781ECA7C25E52CF6, 0xCCE6FC7DACF740DF,
+				0x430A79F6418915A0, 0x0B0BCA0000000000, 0x0000000000000000), 105);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x00000001170CB642, 0xB133E8D97AF3C1A4, 0x0105DCE8C1A888B8,
+				0x9E68C39E8F5AD840, 0x6E75E40000000000, 0x0000000000000000), 106);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000000AE67F1E9A, 0xEC07187ECD859068, 0x0A3AA11790955736,
+				0x3017A431998C7284, 0x509AE80000000000, 0x0000000000000000), 107);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000006D00F7320D, 0x3846F4F40737A410, 0x664A4AEBA5D5681D,
+				0xE0EC69EFFF7C792B, 0x260D100000000000, 0x0000000000000000), 108);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0000044209A7F484, 0x32C59188482C68A3, 0xFEE6ED347A56112A,
+				0xC93C235FFADCBBAF, 0x7C82A00000000000, 0x0000000000000000), 109);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x00002A94608F8D29, 0xFBB7AF52D1BC1667, 0xF505440CC75CABAB,
+				0xDC5961BFCC9F54DA, 0xDD1A400000000000, 0x0000000000000000), 110);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0001A9CBC59B83A3, 0xD52CD93C3158E00F, 0x9234A87FC99EB4B6,
+				0x9B7DD17DFE39508C, 0xA306800000000000, 0x0000000000000000), 111);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x0010A1F5B8132466, 0x53C07C59ED78C09B, 0xB60E94FDE0330F22,
+				0x12EA2EEBEE3D257E, 0x5E41000000000000, 0x0000000000000000), 112);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x00A6539930BF6BFF, 0x4584DB8346B78615, 0x1C91D1EAC1FE9754,
+				0xBD25D5374E6376EF, 0xAE8A000000000000, 0x0000000000000000), 113);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x067F43FBE77A37F8, 0xB7309320C32B3CD3, 0x1DB2332B93F1E94F,
+				0x637A54290FE2A55C, 0xD164000000000000, 0x0000000000000000), 114);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000000, 0x40F8A7D70AC62FB7, 0x27E5BF479FB0603F, 0x28F5FFB3C7731D19,
+				0xE2C7499A9EDA75A0, 0x2DE8000000000000, 0x0000000000000000), 115);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000002, 0x89B68E666BBDDD27, 0x8EF978CC3CE3C277, 0x999BFD05CA7F2302,
+				0xDBC8E00A34889841, 0xCB10000000000000, 0x0000000000000000), 116);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000000019, 0x61219000356AA38B, 0x95BEB7FA60E598AC, 0x0017E239E8F75E1C,
+				0x95D8C0660D55F291, 0xEEA0000000000000, 0x0000000000000000), 117);
+		yield return () => (
+			new(0x0000000000000000, 0x00000000000000FD, 0xCB4FA002162A6373, 0xD9732FC7C8F7F6B8, 0x00EED64319A9AD1D,
+				0xDA7783FC855B79B3, 0x5240000000000000, 0x0000000000000000), 118);
+		yield return () => (
+			new(0x0000000000000000, 0x00000000000009E9, 0xF11C4014DDA7E286, 0x7E7FDDCDD9AFA330, 0x09545E9F00A0C32A,
+				0x88AB27DD3592C101, 0x3680000000000000, 0x0000000000000000), 119);
+		yield return () => (
+			new(0x0000000000000000, 0x0000000000006323, 0x6B1A80D0A88ED940, 0xF0FEAA0A80DC5FE0, 0x5D4BB23606479FA9,
+				0x56AF8EA417BB8A0C, 0x2100000000000000, 0x0000000000000000), 120);
+		yield return () => (
+			new(0x0000000000000000, 0x000000000003DF62, 0x2F09082695947C89, 0x69F2A469089BBEC3, 0xA4F4F61C3ECC3C9D,
+				0x62DB9268ED536479, 0x4A00000000000000, 0x0000000000000000), 121);
+		yield return () => (
+			new(0x0000000000000000, 0x000000000026B9D5, 0xD65A5181D7CCDD5E, 0x237A6C1A561573A4, 0x71919D1A73FA5E25,
+				0xDC93B8194541ECBC, 0xE400000000000000, 0x0000000000000000), 122);
+		yield return () => (
+			new(0x0000000000000000, 0x000000000183425A, 0x5F872F126E00A5AD, 0x62C839075CD6846C, 0x6FB0230887C7AD7A,
+				0x9DC530FCB4933F60, 0xE800000000000000, 0x0000000000000000), 123);
+		yield return () => (
+			new(0x0000000000000000, 0x000000000F209787, 0xBB47D6B84C0678C5, 0xDBD23A49A0612C3C, 0x5CE15E554DCCC6CA,
+				0x29B3E9DF0DC079C9, 0x1000000000000000, 0x0000000000000000), 124);
+		yield return () => (
+			new(0x0000000000000000, 0x000000009745EB4D, 0x50CE6332F840B7BA, 0x963646E043CBBA5B, 0xA0CDAF5509FFC3E5,
+				0xA10722B68984C1DA, 0xA000000000000000, 0x0000000000000000), 125);
+		yield return () => (
+			new(0x0000000000000000, 0x00000005E8BB3105, 0x280FDFFDB2872D49, 0xDE1EC4C2A5F54794, 0x4808D95263FDA6F8,
+				0x4A475B215F2F928A, 0x4000000000000000, 0x0000000000000000), 126);
+		yield return () => (
+			new(0x0000000000000000, 0x0000003B174FEA33, 0x909EBFE8F947C4E2, 0xAD33AF9A7B94CBCA, 0xD0587D37E7E885B2,
+				0xE6C98F4DB7DBB966, 0x8000000000000000, 0x0000000000000000), 127);
+		yield return () => (
+			new(0x0000000000000000, 0x0000024EE91F2603, 0xA6337F19BCCDB0DA, 0xC404DC08D3CFF5EC, 0x2374E42F0F1538FD,
+				0x03DF99092E953E01, 0x0000000000000000, 0x0000000000000000), 128);
+		yield return () => (
+			new(0x0000000000000000, 0x000017151B377C24, 0x7E02F7016008E88B, 0xA8309858461F9B39, 0x6290E9D696D439E2,
+				0x26BBFA5BD1D46C0A, 0x0000000000000000, 0x0000000000000000), 129);
+		yield return () => (
+			new(0x0000000000000000, 0x0000E6D3102AD96C, 0xEC1DA60DC0591574, 0x91E5F372BD3C103D, 0xD9A92261E44A42D5,
+				0x8357C796324C3864, 0x0000000000000000, 0x0000000000000000), 130);
+		yield return () => (
+			new(0x0000000000000000, 0x0009043EA1AC7E41, 0x39287C89837AD68D, 0xB2FB827B6458A26A, 0x809B57D2EAE69C57,
+				0x216DCBDDF6FA33E8, 0x0000000000000000, 0x0000000000000000), 131);
+		yield return () => (
+			new(0x0000000000000000, 0x005A2A7250BCEE8C, 0x3B94DD5F22CC6188, 0xFDD318D1EB765829, 0x06116E3D2D021B67,
+				0x4E49F6ABA5C60710, 0x0000000000000000, 0x0000000000000000), 132);
+		yield return () => (
+			new(0x0000000000000000, 0x0385A8772761517A, 0x53D0A5B75BFBCF59, 0xEA3EF833329F719A, 0x3CAE4E63C2151209,
+				0x0EE3A2B479BC46A0, 0x0000000000000000, 0x0000000000000000), 133);
+		yield return () => (
+			new(0x0000000000000000, 0x233894A789CD2EC7, 0x4626792997D61983, 0x2675B1FFFA3A7006, 0x5ECF0FE594D2B45A,
+				0x94E45B0CC15AC240, 0x0000000000000000, 0x0000000000000000), 134);
+		yield return () => (
+			new(0x0000000000000001, 0x6035CE8B6203D3C8, 0xBD80BB9FEE5CFF1F, 0x8098F3FFC648603F, 0xB4169EF7D03B0B89,
+				0xD0EB8E7F8D8B9680, 0x0000000000000000, 0x0000000000000000), 135);
+		yield return () => (
+			new(0x000000000000000D, 0xC21A1171D42645D7, 0x6707543F4FA1F73B, 0x05F987FDBED3C27D, 0x08E235AE224E7362,
+				0x293390FB8773E100, 0x0000000000000000, 0x0000000000000000), 136);
+		yield return () => (
+			new(0x0000000000000089, 0x9504AE72497EBA6A, 0x06494A791C53A84E, 0x3BBF4FE9744598E2, 0x58D618CD571081D5,
+				0x9C03A9D34A86CA00, 0x0000000000000000, 0x0000000000000000), 137);
+		yield return () => (
+			new(0x000000000000055F, 0xD22ED076DEF34824, 0x3EDCE8BB1B44930E, 0x55791F1E8AB7F8D7, 0x785CF80566A51258,
+				0x1824A240E943E400, 0x0000000000000000, 0x0000000000000000), 138);
+		yield return () => (
+			new(0x00000000000035BE, 0x35D424A4B580D16A, 0x74A1174F10ADBE8F, 0x56BB37316B2FB86A, 0xB3A1B0360272B770,
+				0xF16E56891CA6E800, 0x0000000000000000, 0x0000000000000000), 139);
+		yield return () => (
+			new(0x000000000002196E, 0x1A496E6F17082E28, 0x8E4AE916A6C97199, 0x635027EE2FDD342B, 0x0450E21C187B2A69,
+				0x6E4F615B1E851000, 0x0000000000000000, 0x0000000000000000), 140);
+		yield return () => (
+			new(0x000000000014FE4D, 0x06DE5056E651CD95, 0x8EED1AE283DE6FFD, 0xE1218F4DDEA409AE, 0x2B28D518F4CFA81E,
+				0x4F19CD8F3132A000, 0x0000000000000000, 0x0000000000000000), 141);
+		yield return () => (
+			new(0x0000000000D1EF02, 0x44AF2364FF3207D7, 0x95430CD926B05FEA, 0xCB4F990AB26860CD, 0xAF9852F9901C912F,
+				0x17020797EBFA4000, 0x0000000000000000, 0x0000000000000000), 142);
+		yield return () => (
+			new(0x0000000008335616, 0xAED761F1F7F44E6B, 0xD49E807B82E3BF2B, 0xF11BFA6AF813C808, 0xDBF33DBFA11DABD6,
+				0xE6144BEF37C68000, 0x0000000000000000, 0x0000000000000000), 143);
+		yield return () => (
+			new(0x0000000052015CE2, 0xD469D373AF8B1036, 0x4E3104D31CE577B7, 0x6B17C82DB0C5D058, 0x9780697C4B28B664,
+				0xFCCAF7582DC10000, 0x0000000000000000, 0x0000000000000000), 144);
+		yield return () => (
+			new(0x00000003340DA0DC, 0x4C224284DB6EA21F, 0x0DEA303F20F6AD2A, 0x2EEDD1C8E7BA2375, 0xEB041EDAEF971FF1,
+				0xDFEDA971C98A0000, 0x0000000000000000, 0x0000000000000000), 145);
+		yield return () => (
+			new(0x000000200888489A, 0xF956993092525536, 0x8B25E27749A2C3A5, 0xD54A31D90D45629B, 0x2E29348D5BE73F72,
+				0xBF489E71DF640000, 0x0000000000000000, 0x0000000000000000), 146);
+		yield return () => (
+			new(0x000001405552D60D, 0xBD61FBE5B7375421, 0x6F7AD8A8E05BA47A, 0x54E5F27A84B5DA0F, 0xCD9C0D8597087A7B,
+				0x78D63072B9E80000, 0x0000000000000000, 0x0000000000000000), 147);
+		yield return () => (
+			new(0x00000C83553C5C89, 0x65D3D6F92829494E, 0x5ACC7698C3946CC7, 0x50FB78C92F1A849E, 0x08188737E654C8D2,
+				0xB85DE47B43100000, 0x0000000000000000, 0x0000000000000000), 148);
+		yield return () => (
+			new(0x00007D21545B9D5D, 0xFA4665BB919CDD0F, 0x8BFCA1F7A3CC3FC9, 0x29D2B7DBD7092E2C, 0x50F5482EFF4FD83B,
+				0x33AAECD09EA00000, 0x0000000000000000, 0x0000000000000000), 149);
+		yield return () => (
+			new(0x0004E34D4B9425AB, 0xC6BFF953B020A29B, 0x77DE53AC65FA7DDB, 0xA23B2E96665BCDBB, 0x2994D1D5F91E7250,
+				0x04AD402632400000, 0x0000000000000000, 0x0000000000000000), 150);
+		yield return () => (
+			new(0x0030E104F3C978B5, 0xC37FBD44E1465A12, 0xAEAF44BBFBC8EA94, 0x564FD1DFFF96094F, 0x9FD0325BBB307720,
+				0x2EC4817DF6800000, 0x0000000000000000, 0x0000000000000000), 151);
+		yield return () => (
+			new(0x01E8CA3185DEB719, 0xA2FD64B0CCBF84BA, 0xD2D8AF57D5D929CB, 0x5F1E32BFFBDC5D1C, 0x3E21F7954FE4A741,
+				0xD3AD0EEBA1000000, 0x0000000000000000, 0x0000000000000000), 152);
+		yield return () => (
+			new(0x1317E5EF3AB32700, 0x5DE5EEE7FF7B2F4C, 0x3C76D96E5A7BA1F1, 0xB72DFB7FD69BA31A, 0x6D53ABD51EEE8892,
+				0x44C295344A000000, 0x0000000000000000, 0x0000000000000000), 153);
+		yield return () => (
+			new(0xBEEEFB584AFF8603, 0xAAFB550FFACFD8FA, 0x5CA47E4F88D45371, 0x27CBD2FE62145F08, 0x4544B653355155B6,
+				0xAF99D40AE4000000, 0x0000000000000000, 0x0000000000000000), 154);
+	}
+}
diff --git a/src/MissingValues.Tests/Data/Int256DataSources.cs b/src/MissingValues.Tests/Data/Int256DataSources.cs
new file mode 100644
index 0000000..a976966
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Int256DataSources.cs
@@ -0,0 +1,2321 @@
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using MissingValues.Tests.Data.Sources;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class Int256DataSources
+	: IMathOperatorsDataSource<Int256>,
+	IShiftOperatorsDataSource<Int256>,
+	IBitwiseOperatorsDataSource<Int256>,
+	IEqualityOperatorsDataSource<Int256>,
+	IComparisonOperatorsDataSource<Int256>,
+	INumberBaseDataSource<Int256>,
+	INumberDataSource<Int256>,
+	IBinaryNumberDataSource<Int256>,
+	IBinaryIntegerDataSource<Int256>
+{
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_AdditionTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.One, Int256.Zero, Int256.One);
+		yield return () => (Int256.One, Int256.One, new Int256(0, 0, 0, 2));
+		yield return () => (new Int256(0, 0, 1, ulong.MaxValue), new Int256(0, 0, 1, 1), new Int256(0, 0, 3, 0));
+		yield return () => (new Int256(0, 1, ulong.MaxValue, ulong.MaxValue), new Int256(0, 1, 1, 1), new Int256(0, 3, 1, 0));
+		yield return () => (new Int256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(1, 1, 1, 1), new Int256(3, 1, 1, 0));
+		yield return () => (Int256.MaxValue, Int256.One, Int256.MinValue);
+		yield return () => (Int256.NegativeOne, Int256.One, Int256.Zero);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256, bool)>> op_CheckedAdditionTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero, false);
+		yield return () => (Int256.One, Int256.Zero, Int256.One, false);
+		yield return () => (Int256.One, Int256.One, new Int256(0, 0, 0, 2), false);
+		yield return () => (new Int256(0, 0, 1, ulong.MaxValue), new Int256(0, 0, 1, 1), new Int256(0, 0, 3, 0), false);
+		yield return () => (new Int256(0, 1, ulong.MaxValue, ulong.MaxValue), new Int256(0, 1, 1, 1), new Int256(0, 3, 1, 0), false);
+		yield return () => (new Int256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(1, 1, 1, 1), new Int256(3, 1, 1, 0), false);
+		yield return () => (Int256.MaxValue, Int256.One, Int256.MinValue, true);
+		yield return () => (Int256.NegativeOne, Int256.One, Int256.Zero, false);
+		yield return () => (Int256.MinValue, Int256.NegativeOne, Int256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_CheckedDecrementTestData()
+	{
+		yield return () => (Int256.Zero, Int256.NegativeOne, false);
+		yield return () => (Int256.One, Int256.Zero, false);
+		yield return () => (new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 1), false);
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 0, 0, ulong.MaxValue), false);
+		yield return () => (new Int256(0, 1, 0, 0), new Int256(0, 0, ulong.MaxValue, ulong.MaxValue), false);
+		yield return () => (new Int256(1, 0, 0, 0), new Int256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), false);
+		yield return () => (Int256.MinValue, Int256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_CheckedIncrementTestData()
+	{
+		yield return () => (Int256.Zero, Int256.One, false);
+		yield return () => (Int256.One, new Int256(0, 0, 0, 2), false);
+		yield return () => (Int256.MaxValue, Int256.Zero, true);
+		yield return () => (Int256.NegativeOne, Int256.Zero, false);
+		yield return () => (new Int256(0, 0, 0, ulong.MaxValue), new Int256(0, 0, 1, 0), false);
+		yield return () => (new Int256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(1, 0, 0, 0), false);
+		yield return () => (new Int256(unchecked((ulong)-123456789), 987654321, 555555555, 999999999), new Int256(unchecked((ulong)-123456789), 987654321, 555555555, 1000000000), false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256, bool)>> op_CheckedMultiplyTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero, false);
+		yield return () => (Int256.One, Int256.One, Int256.One, false);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne, false);
+		yield return () => (Int256.NegativeOne, Int256.NegativeOne, Int256.One, false);
+		yield return () => (new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 3), new Int256(0, 0, 0, 6), false);
+		yield return () => (Int256.MaxValue, Int256.One, Int256.MaxValue, false);
+		yield return () => (Int256.MaxValue, new Int256(0, 0, 0, 2), default, true);
+		yield return () => (Int256.MinValue, Int256.NegativeOne, default, true);
+		yield return () => (new Int256(0, 0, 0, ulong.MaxValue), new Int256(0, 0, 0, ulong.MaxValue), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFE, 0x0000_0000_0000_0001), false);
+		yield return () => (new Int256(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(2, 0, 0, 0), new Int256(0xFFFF_FFFF_FFFF_FFFE, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), false);
+		yield return () => (new Int256(long.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(2, 0, 0, 0), default, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256, bool)>> op_CheckedSubtractionTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero, false);
+		yield return () => (Int256.One, Int256.Zero, Int256.One, false);
+		yield return () => (Int256.One, Int256.One, Int256.Zero, false);
+		yield return () => (new Int256(0, 0, 0, 2), Int256.One, Int256.One, false);
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 0, 0, 1), new Int256(0, 0, 0, ulong.MaxValue), false);
+		yield return () => (new Int256(0, 1, 0, 0), new Int256(0, 0, ulong.MaxValue, ulong.MaxValue), new Int256(0, 0, 0, 1), false);
+		yield return () => (Int256.MinValue, Int256.One, Int256.MaxValue, true);
+		yield return () => (Int256.MaxValue, Int256.NegativeOne, Int256.MinValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> op_DecrementTestData()
+	{
+		yield return () => (Int256.Zero, Int256.NegativeOne);
+		yield return () => (Int256.One, Int256.Zero);
+		yield return () => (new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 1));
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 0, 0, ulong.MaxValue));
+		yield return () => (new Int256(0, 1, 0, 0), new Int256(0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new Int256(1, 0, 0, 0), new Int256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (Int256.MinValue, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_DivisionTestData()
+	{
+		yield return () => (Int256.Zero, Int256.One, Int256.Zero);
+		yield return () => (Int256.One, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.NegativeOne, Int256.One, Int256.NegativeOne);
+		yield return () => (new Int256(0, 0, 0, 4), new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 2));
+		yield return () => (Int256.MaxValue, Int256.One, Int256.MaxValue);
+		yield return () => (Int256.MinValue, Int256.One, Int256.MinValue);
+		yield return () => (Int256.Zero, Int256.MaxValue, Int256.Zero);
+		yield return () => (Int256.MaxValue, Int256.MaxValue, Int256.One);
+		yield return () => (Int256.MinValue, Int256.MinValue, Int256.One);
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 1, 0, 0), Int256.Zero);
+		yield return () => (new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000));
+		yield return () => (new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000));
+		yield return () => (new Int256(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 0, 10), new Int256(0x0CCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC));
+		yield return () => (new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0, 0, 0, 10), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0CCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0, 0, 0, 10), new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xF333_3333_3333_3333, 0x3333_3333_3333_3334));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> op_IncrementTestData()
+	{
+		yield return () => (Int256.Zero, Int256.One);
+		yield return () => (Int256.One, new Int256(0, 0, 0, 2));
+		yield return () => (Int256.MaxValue, Int256.MinValue);
+		yield return () => (Int256.NegativeOne, Int256.Zero);
+		yield return () => (new Int256(0, 0, 0, ulong.MaxValue), new Int256(0, 0, 1, 0));
+		yield return () => (new Int256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(1, 0, 0, 0));
+		yield return () => (new Int256(123456789, 987654321, 555555555, 999999999), new Int256(123456789, 987654321, 555555555, 1000000000));
+		yield return () => (new Int256(0x8000000000000000, 0, 0, 0),new Int256(0x8000000000000000, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_ModulusTestData()
+	{
+		yield return () => (Int256.Zero, Int256.One, Int256.Zero);
+		yield return () => (Int256.One, Int256.One, Int256.Zero);
+		yield return () => (new Int256(0, 0, 0, 123456789), Int256.One, Int256.Zero);
+		yield return () => (Int256.MaxValue, Int256.MaxValue, Int256.Zero);
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 1, 0, 0), new Int256(0, 0, 1, 0));
+		yield return () => (new Int256(0, 0, 0, 10), new Int256(0, 0, 0, 3), new Int256(0, 0, 0, 1));
+		yield return () => (new Int256(0, 0, 0, 15), new Int256(0, 0, 0, 5), Int256.Zero);
+		yield return () => (Int256.NegativeOne, new Int256(0, 0, 0, 2), Int256.NegativeOne);
+		yield return () => (new Int256(0, 0, 0, 7), Int256.NegativeOne, Int256.Zero);
+		yield return () => (Int256.MaxValue, new Int256(0, 0, 0, 123456789), new Int256(0, 0, 0, 77645365));
+		yield return () => (new Int256(0x0000_0000_0000_0040, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int256(0x0000_0000_0000_000F, 0xEE50_B702_5C36_A080, 0x2F23_6D04_753D_5B48, 0xE800_0000_0000_0000), new Int256(0x0000_0000_0000_0000, 0x46BD_23F6_8F25_7DFF, 0x4372_4BEE_2B0A_92DC, 0x6000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_MultiplyTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.Zero, Int256.One, Int256.Zero);
+		yield return () => (Int256.One, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.NegativeOne, Int256.NegativeOne, Int256.One);
+		yield return () => (new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 3), new Int256(0, 0, 0, 6));
+		yield return () => (new Int256(0, 0, 0, ulong.MaxValue), new Int256(0, 0, 0, 2), new Int256(0, 0, 1, ulong.MaxValue - 1));
+		yield return () => (new Int256(0, 0, 0, ulong.MaxValue), new Int256(0, 0, 0, ulong.MaxValue), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFE, 0x0000_0000_0000_0001));
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 0, 1, 0), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_SubtractionTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.One, Int256.Zero, Int256.One);
+		yield return () => (Int256.One, Int256.One, Int256.Zero);
+		yield return () => (Int256.Zero, Int256.One, Int256.NegativeOne);
+		yield return () => (Int256.MaxValue,Int256.One, new Int256(0x7FFF_FFFF_FFFF_FFFF, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue - 1));
+		yield return () => (Int256.MinValue,Int256.One,Int256.MaxValue);
+		yield return () => (Int256.MinValue,Int256.NegativeOne, new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
+		yield return () => (new Int256(1, 2, 3, 4),new Int256(0, 1, 2, 3),new Int256(1, 1, 1, 1));
+		yield return () => (new Int256(0, 0, 0, 0),new Int256(0, 0, 0, 1),new Int256(unchecked((ulong)-1), ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> op_UnaryNegationTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_CheckedUnaryNegationTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, int, Int256)>> op_ShiftLeftTestData()
+	{
+		yield return () => (Int256.Zero, 100, Int256.Zero);
+		yield return () => (Int256.One, 0, Int256.One);
+		yield return () => (Int256.One, 1, new Int256(0, 0, 0, 2));
+		yield return () => (Int256.One, 2, new Int256(0, 0, 0, 4));
+		yield return () => (Int256.One, 64, new Int256(0, 0, 1, 0));
+		yield return () => (Int256.One, 128, new Int256(0, 1, 0, 0));
+		yield return () => (Int256.One, 192, new Int256(1, 0, 0, 0));
+		yield return () => (new Int256(0, 0, 0, 0xFFFF_FFFF_FFFF_FFFF), 32, new Int256(0, 0, 0xFFFF_FFFF, 0xFFFF_FFFF_0000_0000));
+		yield return () => (new Int256(0, 0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), 96, new Int256(0xFFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_0000_0000, 0));
+		yield return () => (Int256.One, 256, Int256.One);
+	}
+
+	public static IEnumerable<Func<(Int256, int, Int256)>> op_ShiftRightTestData()
+	{
+		yield return () => (Int256.Zero, 100, Int256.Zero);
+		yield return () => (Int256.One, 0, Int256.One);
+		yield return () => (new Int256(1, 0, 0, 0), 64, new Int256(0, 1, 0, 0));
+		yield return () => (new Int256(1, 0, 0, 0), 128, new Int256(0, 0, 1, 0));
+		yield return () => (new Int256(1, 0, 0, 0), 192, new Int256(0, 0, 0, 1));
+		yield return () => (new Int256(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0), 031, new Int256(0b1111111111111111111111111111111100000000000000000000000000000000, 0, 0, 0));
+		yield return () => (new Int256(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0), 127, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0));
+		yield return () => (new Int256(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0), 255, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => (Int256.One, 256, Int256.One);
+	}
+
+	public static IEnumerable<Func<(Int256, int, Int256)>> op_UnsignedShiftRightTestData()
+	{
+		yield return () => (Int256.Zero, 100, Int256.Zero);
+		yield return () => (Int256.One, 0, Int256.One);
+		yield return () => (new Int256(1, 0, 0, 0), 64, new Int256(0, 1, 0, 0));
+		yield return () => (new Int256(1, 0, 0, 0), 128, new Int256(0, 0, 1, 0));
+		yield return () => (new Int256(1, 0, 0, 0), 192, new Int256(0, 0, 0, 1));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0, 0, 0), 64, new Int256(0, 0xFFFF_FFFF_FFFF_FFFF, 0, 0));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0, 0, 0), 128, new Int256(0, 0, 0xFFFF_FFFF_FFFF_FFFF, 0));
+		yield return () => (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0, 0, 0), 192, new Int256(0, 0, 0, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (Int256.One, 256, Int256.One);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_BitwiseAndTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.Zero, Int256.MaxValue, Int256.Zero);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(1, 2, 3, 4), Int256.MaxValue, new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(0xFFFFFFFF00000000, 0xAAAAAAAA55555555, 0x123456789ABCDEF0, 0x0F0F0F0F0F0F0F0F), new Int256(0x00000000FFFFFFFF, 0x55555555AAAAAAAA, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new Int256(0x0000000000000000, 0x0000000000000000, 0x020406080A0C0E00, 0x0000000000000000));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_BitwiseOrTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.Zero, Int256.MaxValue, Int256.MaxValue);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(1, 2, 3, 4), Int256.MaxValue, new Int256(long.MaxValue | 1, ulong.MaxValue | 2, ulong.MaxValue | 3, ulong.MaxValue | 4));
+		yield return () => (new Int256(0x00000000FFFFFFFF, 0xAAAAAAAA00000000, 0x00000000AAAAAAAA, 0x1234567890ABCDEF), new Int256(0xFFFFFFFF00000000, 0x0000000055555555, 0x5555555500000000, 0xFEDCBA9876543210), new Int256(0xFFFFFFFFFFFFFFFF, 0xAAAAAAAA55555555, 0x55555555AAAAAAAA, 0x1234567890ABCDEF | 0xFEDCBA9876543210));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> op_BitwiseXorTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, Int256.Zero);
+		yield return () => (Int256.Zero, Int256.MaxValue, Int256.MaxValue);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4), Int256.Zero);
+		yield return () => (new Int256(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x1234567890ABCDEF, 0xFEDCBA9876543210), new Int256(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(ulong.MaxValue, 0x0, 0xEDCBA9876F543210, 0x0123456789ABCDEF));
+		yield return () => (new Int256(0x1234567890ABCDEF, 0xAAAAAAAA00000000, 0x00000000AAAAAAAA, 0xFFFFFFFFFFFFFFFF), new Int256(0xFFFFFFFFFFFFFFFF, 0x00000000AAAAAAAA, 0xAAAAAAAA00000000, 0x0000000000000000), new Int256(0xEDCBA9876F543210, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xFFFFFFFFFFFFFFFF));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> op_OnesComplementTestData()
+	{
+		yield return () => (Int256.Zero, new Int256(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new Int256(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), Int256.Zero);
+		yield return () => (new Int256(0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555), new Int256(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA));
+		yield return () => (new Int256(0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new Int256(~(ulong)0x0123456789ABCDEF, ~0xFEDCBA9876543210, ~(ulong)0x0F0F0F0F0F0F0F0F, ~0xF0F0F0F0F0F0F0F0));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_EqualityTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, true);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4), true);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 5), false);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 4, 4), false);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 3, 3, 4), false);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(2, 2, 3, 4), false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_InequalityTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, false);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 4), false);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 3, 5), true);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 2, 4, 4), true);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(1, 3, 3, 4), true);
+		yield return () => (new Int256(1, 2, 3, 4), new Int256(2, 2, 3, 4), true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_GreaterThanOrEqualTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, true);
+		yield return () => (Int256.NegativeOne, Int256.One, false);
+		yield return () => (Int256.One, Int256.NegativeOne, true);
+		yield return () => (Int256.Zero, Int256.MinValue, true);
+		yield return () => (Int256.Zero, Int256.NegativeOne, true);
+		yield return () => (Int256.Zero, Int256.One, false);
+		yield return () => (Int256.Zero, Int256.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_GreaterThanTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, false);
+		yield return () => (Int256.NegativeOne, Int256.One, false);
+		yield return () => (Int256.One, Int256.NegativeOne, true);
+		yield return () => (Int256.Zero, Int256.MinValue, true);
+		yield return () => (Int256.Zero, Int256.NegativeOne, true);
+		yield return () => (Int256.Zero, Int256.One, false);
+		yield return () => (Int256.Zero, Int256.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_LessThanOrEqualTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, true);
+		yield return () => (Int256.NegativeOne, Int256.One, true);
+		yield return () => (Int256.One, Int256.NegativeOne, false);
+		yield return () => (Int256.Zero, Int256.MinValue, false);
+		yield return () => (Int256.Zero, Int256.NegativeOne, false);
+		yield return () => (Int256.Zero, Int256.One, true);
+		yield return () => (Int256.Zero, Int256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, bool)>> op_LessThanTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero, false);
+		yield return () => (Int256.NegativeOne, Int256.One, true);
+		yield return () => (Int256.One, Int256.NegativeOne, false);
+		yield return () => (Int256.Zero, Int256.MinValue, false);
+		yield return () => (Int256.Zero, Int256.NegativeOne, false);
+		yield return () => (Int256.Zero, Int256.One, true);
+		yield return () => (Int256.Zero, Int256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> AbsTestData()
+	{
+		yield return () => (Int256.Zero, Int256.Zero);
+		yield return () => (Int256.One, Int256.One);
+		yield return () => (Int256.NegativeOne, Int256.One);
+		yield return () => (Int256.MinValue + Int256.One, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsCanonicalTestData()
+	{
+		yield return () => (Int256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsComplexNumberTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsEvenIntegerTestData()
+	{
+		yield return () => (Int256.Zero, true);
+		yield return () => (Int256.One, false);
+		yield return () => (Int256.NegativeOne, false);
+		yield return () => (new Int256(0, 0, 0, 2), true);
+		yield return () => (new Int256(0, 0, 0, 3), false);
+		yield return () => (new Int256(0, 0, 0, 4), true);
+		yield return () => (new Int256(0, 0, 0, 6), true);
+		yield return () => (new Int256(0, 0, 0, 8), true);
+		yield return () => (new Int256(0, 0, 0, 16), true);
+		yield return () => (-new Int256(0, 0, 0, 2), true);
+		yield return () => (-new Int256(0, 0, 0, 3), false);
+		yield return () => (-new Int256(0, 0, 0, 4), true);
+		yield return () => (-new Int256(0, 0, 0, 6), true);
+		yield return () => (-new Int256(0, 0, 0, 8), true);
+		yield return () => (-new Int256(0, 0, 0, 16), true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsFiniteTestData()
+	{
+		yield return () => (Int256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsImaginaryNumberTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsInfinityTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsIntegerTestData()
+	{
+		yield return () => (Int256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsNaNTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsNegativeTestData()
+	{
+		yield return () => (Int256.Zero, false);
+		yield return () => (Int256.One, false);
+		yield return () => (Int256.MaxValue, false);
+		yield return () => (Int256.NegativeOne, true);
+		yield return () => (-Int256.One, true);
+		yield return () => (-Int256.MaxValue, true);
+		yield return () => (Int256.MinValue, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsNegativeInfinityTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsNormalTestData()
+	{
+		yield return () => (Int256.Zero, false);
+		yield return () => (Int256.One, true);
+		yield return () => (Int256.NegativeOne, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsOddIntegerTestData()
+	{
+		yield return () => (Int256.Zero, false);
+		yield return () => (Int256.One, true);
+		yield return () => (Int256.NegativeOne, true);
+		yield return () => (new Int256(0, 0, 0, 2), false);
+		yield return () => (new Int256(0, 0, 0, 3), true);
+		yield return () => (new Int256(0, 0, 0, 4), false);
+		yield return () => (new Int256(0, 0, 0, 6), false);
+		yield return () => (new Int256(0, 0, 0, 8), false);
+		yield return () => (new Int256(0, 0, 0, 16), false);
+		yield return () => (-new Int256(0, 0, 0, 2), false);
+		yield return () => (-new Int256(0, 0, 0, 3), true);
+		yield return () => (-new Int256(0, 0, 0, 4), false);
+		yield return () => (-new Int256(0, 0, 0, 6), false);
+		yield return () => (-new Int256(0, 0, 0, 8), false);
+		yield return () => (-new Int256(0, 0, 0, 16), false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsPositiveTestData()
+	{
+		yield return () => (Int256.Zero, true);
+		yield return () => (Int256.One, true);
+		yield return () => (Int256.MaxValue, true);
+		yield return () => (Int256.NegativeOne, false);
+		yield return () => (-Int256.One, false);
+		yield return () => (-Int256.MaxValue, false);
+		yield return () => (Int256.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsPositiveInfinityTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsRealNumberTestData()
+	{
+		yield return () => (Int256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsSubnormalTestData()
+	{
+		yield return () => (Int256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsZeroTestData()
+	{
+		yield return () => (Int256.Zero, true);
+		yield return () => (Int256.One, false);
+		yield return () => (Int256.NegativeOne, false);
+		yield return () => (Int256.MaxValue, false);
+		yield return () => (Int256.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MaxMagnitudeTestData()
+	{
+		yield return () => (Int256.MaxValue, 5, Int256.MaxValue);
+		yield return () => (Int256.One, 5, 5);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.One);
+		yield return () => (Int256.One, -2, -2);
+		yield return () => (Int256.NegativeOne, Int256.MaxValue, Int256.MaxValue);
+		yield return () => (Int256.MinValue, -2, Int256.MinValue);
+		yield return () => (Int256.MaxValue, Int256.MinValue, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MaxMagnitudeNumberTestData()
+	{
+		yield return () => (Int256.MaxValue, 5, Int256.MaxValue);
+		yield return () => (Int256.One, 5, 5);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.One);
+		yield return () => (Int256.One, -2, -2);
+		yield return () => (Int256.NegativeOne, Int256.MaxValue, Int256.MaxValue);
+		yield return () => (Int256.MinValue, -2, Int256.MinValue);
+		yield return () => (Int256.MaxValue, Int256.MinValue, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MinMagnitudeTestData()
+	{
+		yield return () => (Int256.MaxValue, 5, 5);
+		yield return () => (Int256.One, 5, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.One, -2, Int256.One);
+		yield return () => (Int256.NegativeOne, Int256.MaxValue, Int256.NegativeOne);
+		yield return () => (Int256.MinValue, -2, -2);
+		yield return () => (Int256.MaxValue, Int256.MinValue, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MinMagnitudeNumberTestData()
+	{
+		yield return () => (Int256.MaxValue, 5, 5);
+		yield return () => (Int256.One, 5, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.One, -2, Int256.One);
+		yield return () => (Int256.NegativeOne, Int256.MaxValue, Int256.NegativeOne);
+		yield return () => (Int256.MinValue, -2, -2);
+		yield return () => (Int256.MaxValue, Int256.MinValue, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256, Int256)>> MultiplyAddEstimateTestData()
+	{
+		yield return () => (Int256.One, Int256.One, Int256.One, 2);
+		yield return () => (Int256.One, Int256.Zero, Int256.One, Int256.One);
+		yield return () => (Int256.MaxValue, Int256.NegativeOne, Int256.NegativeOne, Int256.MinValue);
+		yield return () => (200, 100, 500, 20500);
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, Int256)>> ParseTestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968", NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.NegativeOne);
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967", NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000", NumberStyles.Number, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("1,000.0", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000", NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, Int256)>> ParseSpanTestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.NegativeOne);
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("1,000.0".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000".ToCharArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, Int256)>> ParseUtf8TestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.NegativeOne);
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, Int256.One);
+		yield return () => ("1,000.0"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, Int256)>> TryParseTestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819969", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.NegativeOne);
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MaxValue);
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819968", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000", NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("1,000.0", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000", NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, Int256)>> TryParseSpanTestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819969".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.NegativeOne);
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MaxValue);
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819968".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("1,000.0".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, Int256)>> TryParseUtf8TestData()
+	{
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819969"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MinValue);
+		yield return () => ("-170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.NegativeOne);
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => ("170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819967"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int256.MaxValue);
+		yield return () => ("57896044618658097711785492504343953926634992332820282019728792003956564819968"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+        		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+        		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.One);
+		yield return () => ("1,000.0"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int256, string, IFormatProvider?, string)>> ToStringTestData()
+	{
+		yield return () => (Int256.MaxValue, "e25", CultureInfo.InvariantCulture, "5.7896044618658097711785493e+76");
+		yield return () => (Int256.MinValue, "e25", CultureInfo.InvariantCulture, "-5.7896044618658097711785493e+76");
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256, Int256)>> ClampTestData()
+	{
+		yield return () => (
+			new Int256(0, 0, 0, 1),
+			new Int256(0, 0, 0, 2),
+			new Int256(0, 0, 0, 4),
+			new Int256(0, 0, 0, 2)
+		);
+		yield return () => (
+			new Int256(0, 0, 0, 1),
+			new Int256(0, 0, 0, 1),
+			new Int256(0, 0, 0, 4),
+			new Int256(0, 0, 0, 1)
+		);
+		yield return () => (
+			new Int256(0, 1, 0, 0),
+			new Int256(0, 0, 0, 1),
+			new Int256(1, 0, 0, 0),
+			new Int256(0, 1, 0, 0)
+		);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> CopySignTestData()
+	{
+		yield return () => (Int256.One, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.NegativeOne, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.NegativeOne, Int256.One, Int256.One);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MaxTestData()
+	{
+		yield return () => (Int256.One, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.One);
+		yield return () => (Int256.MinValue, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.Zero, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.MaxValue, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MaxNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MinTestData()
+	{
+		yield return () => (Int256.One, Int256.One, Int256.One);
+		yield return () => (Int256.One, Int256.NegativeOne, Int256.NegativeOne);
+		yield return () => (Int256.MinValue, Int256.NegativeOne, Int256.MinValue);
+		yield return () => (Int256.Zero, Int256.One, Int256.Zero);
+		yield return () => (Int256.One, Int256.MaxValue, Int256.One);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Int256)>> MinNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(Int256, int)>> SignTestData()
+	{
+		yield return () => (Int256.Zero, 0);
+		yield return () => (Int256.MaxValue, 1);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.MinValue, -1);
+		yield return () => (Int256.NegativeOne, -1);
+	}
+
+	public static IEnumerable<Func<(Int256, bool)>> IsPow2TestData()
+	{
+		yield return () => (Int256.Zero, false);
+		yield return () => (Int256.One, true);
+		yield return () => (new Int256(0, 0, 0, 3), false);
+		yield return () => (new Int256(0, 0, 0, 4), true);
+		yield return () => (new Int256(0, 0, 0, 6), false);
+		yield return () => (new Int256(0, 0, 0, 8), true);
+		yield return () => (new Int256(1UL << 62, 0, 0, 0), true);
+		yield return () => (Int256.NegativeOne, false);
+		yield return () => (-new Int256(0, 0, 0, 3), false);
+		yield return () => (-new Int256(0, 0, 0, 4), false);
+		yield return () => (-new Int256(0, 0, 0, 6), false);
+		yield return () => (-new Int256(0, 0, 0, 8), false);
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> Log2TestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 1), new Int256(0, 0, 0, 0));
+		yield return () => (new Int256(0, 0, 0, 2), new Int256(0, 0, 0, 1));
+		yield return () => (new Int256(0, 0, 0, 4), new Int256(0, 0, 0, 2));
+		yield return () => (new Int256(0, 0, 0, 8), new Int256(0, 0, 0, 3));
+		yield return () => (new Int256(0, 0, 0, 1UL << 63), new Int256(0, 0, 0, 63));
+		yield return () => (new Int256(0, 0, 1UL << 5, 0), new Int256(0, 0, 0, 69));
+		yield return () => (new Int256(0, 1UL << 42, 0, 0), new Int256(0, 0, 0, 170));
+		yield return () => (new Int256(1UL << 13, 0, 0, 0), new Int256(0, 0, 0, 205));
+		yield return () => (new Int256(0, 0, 0, 0), new Int256(0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256, Pair<Int256>)>> DivRemTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 0, 10), (new Int256(0, 0, 0, 0xFFFF_FFFF_FFFF_FFFF / 10), new Int256(0, 0, 0, 0xFFFF_FFFF_FFFF_FFFF % 10)));
+		yield return () => (new Int256(0, 0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 0, 10), (new Int256(0, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF) / 10), new Int256(0, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF) % 10)));
+		yield return () => (new Int256(0, 0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 1, 0), (new Int256(0, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF) / new UInt128(1, 0)), new Int256(0, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF) % new UInt128(1, 0))));
+		yield return () => (new Int256(0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 0, 10), (new Int256(0x0000_0000_0000_0000, 0x1999_9999_9999_9999, 0x9999_9999_9999_9999, 0x9999_9999_9999_9999), new Int256(0, 0, 0, 5)));
+		yield return () => (new Int256(0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 0, 1, 0), (new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF)));
+		yield return () => (new Int256(0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0, 1, 0, 0), (new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF), new Int256(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> LeadingZeroCountTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), new Int256(0, 0, 0, 256));
+		yield return () => (new Int256(0, 0, 0, 1), new Int256(0, 0, 0, 255));
+		yield return () => (new Int256(0, 0, 1, 0), new Int256(0, 0, 0, 191));
+		yield return () => (new Int256(0, 1, 0, 0), new Int256(0, 0, 0, 127));
+		yield return () => (new Int256(1, 0, 0, 0), new Int256(0, 0, 0, 63));
+		yield return () => (new Int256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int256(0, 0, 0, 63));
+		yield return () => (new Int256(0, 0, 0, 1UL << 63), new Int256(0, 0, 0, 192));
+		yield return () => (new Int256(0, 0, 1UL << 63, 0), new Int256(0, 0, 0, 128));
+		yield return () => (new Int256(0, 1UL << 63, 0, 0), new Int256(0, 0, 0, 64));
+		yield return () => (new Int256(1UL << 63, 0, 0, 0), new Int256(0, 0, 0, 0));
+		yield return () => (new Int256(1UL << 62, 0, 0, 0), new Int256(0, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> PopCountTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), new Int256(0, 0, 0, 0));
+		yield return () => (new Int256(0, 0, 0, 1), new Int256(0, 0, 0, 1));
+		yield return () => (Int256.MaxValue, new Int256(0, 0, 0, 255));
+		yield return () => (new Int256(ulong.MaxValue, 0, 0, 0), new Int256(0, 0, 0, 64));
+		yield return () => (new Int256(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), new Int256(0, 0, 0, 128));
+		yield return () => (new Int256(1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60), new Int256(0, 0, 0, 4));
+	}
+
+	public static IEnumerable<Func<(byte[], bool, Int256)>> ReadBigEndianTestData()
+	{
+		yield return () => ([], true, Int256.Zero);
+		yield return () => ([0x01], true, Int256.One);
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			Array.Fill(array, byte.MaxValue);
+			return (array, false, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[35];
+			for (int i = 0; i < 35; i++)
+				array[i] = byte.MaxValue;
+			return (array, false, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () => ([0x12, 0x34], true, new Int256(0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			array[0] = 0x80;
+			return (array, false, new Int256(1UL << 63, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(byte[], bool, Int256)>> ReadLittleEndianTestData()
+	{
+		yield return () => ([], true, Int256.Zero);
+		yield return () => ([0x01], true, Int256.One);
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			Array.Fill(array, byte.MaxValue);
+			return (array, false, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[35];
+			for (int i = 0; i < 35; i++)
+				array[i] = byte.MaxValue;
+			return (array, false, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () => ([0x34, 0x12], true, new Int256(0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			array[31] = 0x80;
+			return (array, false, new Int256(1UL << 63, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(Int256, int, Int256)>> RotateLeftTestData()
+	{
+		yield return () => (new Int256(1, 2, 3, 4), 0, new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(1, 2, 3, 4), 256, new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(0, 0, 0x8000_0000_0000_0000, 0), 64, new Int256(0, 0x8000_0000_0000_0000, 0, 0));
+		yield return () => (new Int256(0x8000_0000_0000_0000, 0, 0, 0), 64, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new Int256(0, 0, 0x8000_0000_0000_0000, 0), 128, new Int256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new Int256(0x8000_0000_0000_0000, 0, 0, 0), 128, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(Int256, int, Int256)>> RotateRightTestData()
+	{
+		yield return () => (new Int256(1, 2, 3, 4), 0, new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(1, 2, 3, 4), 256, new Int256(1, 2, 3, 4));
+		yield return () => (new Int256(0, 0, 0x8000_0000_0000_0000, 0), 64, new Int256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new Int256(0, 0, 0, 0x8000_0000_0000_0000), 64, new Int256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new Int256(0, 0, 0x8000_0000_0000_0000, 0), 128, new Int256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new Int256(0x8000_0000_0000_0000, 0, 0, 0), 128, new Int256(0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(Int256, Int256)>> TrailingZeroCountTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), new Int256(0, 0, 0, 256));
+		yield return () => (new Int256(0, 0, 0, 1), new Int256(0, 0, 0, 0));
+		yield return () => (new Int256(0, 0, 8, 0), new Int256(0, 0, 0, 67));
+		yield return () => (new Int256(0, 0x10, 0, 0), new Int256(0, 0, 0, 132));
+		yield return () => (new Int256(0x200, 0, 0, 0), new Int256(0, 0, 0, 201));
+	}
+
+	public static IEnumerable<Func<(Int256, int)>> GetByteCountTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), Unsafe.SizeOf<Int256>());
+	}
+
+	public static IEnumerable<Func<(Int256, int)>> GetShortestBitLengthTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), 0);
+		yield return () => (new Int256(0, 0, 0, 1), 1);
+		yield return () => (new Int256(1, 0, 0, 0), 193);
+		yield return () => (Int256.MaxValue, 255);
+		yield return () => (Int256.MinValue, 256);
+	}
+
+	public static IEnumerable<Func<(Int256, byte[], int)>> WriteBigEndianTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), new byte[32], Unsafe.SizeOf<Int256>());
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 31; i++)
+				buffer[i] = 0;
+
+			buffer[31] = 1;
+			
+			return (new Int256(0, 0, 0, 1), buffer, Unsafe.SizeOf<Int256>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 32; i++)
+				buffer[i] = 0xFF;
+			
+			return (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), buffer, Unsafe.SizeOf<Int256>());
+		};
+	}
+
+	public static IEnumerable<Func<(Int256, byte[], int)>> WriteLittleEndianTestData()
+	{
+		yield return () => (new Int256(0, 0, 0, 0), new byte[32], Unsafe.SizeOf<Int256>());
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			buffer[0] = 1;
+			for (int i = 1; i < 32; i++)
+				buffer[i] = 0;
+			
+			return (new Int256(0, 0, 0, 1), buffer, Unsafe.SizeOf<Int256>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 32; i++)
+				buffer[i] = 0xFF;
+			
+			return (new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), buffer, Unsafe.SizeOf<Int256>());
+		};
+	}
+	
+	public static IEnumerable<Func<(Int256, byte)>> ConvertToCheckedByteTestData()
+	{
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, byte)>> ConvertToSaturatingByteTestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.MaxValue, byte.MaxValue);
+		yield return () => (Int256.ByteMaxValue + Int256.One, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, byte)>> ConvertToTruncatingByteTestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.NegativeOne, 0xFF);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.MaxValue, byte.MaxValue);
+		yield return () => (Int256.ByteMaxValue + Int256.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int256, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt16MaxValue + Int256.One, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.NegativeOne, 0xFFFF);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt16MaxValue + Int256.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int256, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt32MaxValue + Int256.One, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.NegativeOne, 0xFFFF_FFFF);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt32MaxValue + Int256.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int256, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int256.MaxValue, ulong.MaxValue);
+		yield return () => (Int256.UInt64MaxValue + Int256.One, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.NegativeOne, 0xFFFF_FFFF_FFFF_FFFF);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int256.MaxValue, ulong.MaxValue);
+		yield return () => (Int256.UInt64MaxValue + Int256.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int256, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		yield return () => (Int256.One, UInt128.One);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		yield return () => (Int256.MinValue, UInt128.Zero);
+		yield return () => (Int256.One, UInt128.One);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (Int256.MaxValue, UInt128.MaxValue);
+		yield return () => (Int256.UInt128MaxValue + Int256.One, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		yield return () => (Int256.MinValue, UInt128.Zero);
+		yield return () => (Int256.NegativeOne, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (Int256.One, UInt128.One);
+		yield return () => (Int256.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (Int256.MaxValue, UInt128.MaxValue);
+		yield return () => (Int256.UInt128MaxValue + Int256.One, UInt128.Zero);
+	}
+
+	public static IEnumerable<Func<(Int256, UInt256)>> ConvertToCheckedUInt256TestData()
+	{
+		yield return () => (Int256.One, UInt256.One);
+		yield return () => (Int256.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt256.Int256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt256)>> ConvertToSaturatingUInt256TestData()
+	{
+		yield return () => (Int256.MinValue, UInt256.Zero);
+		yield return () => (Int256.One, UInt256.One);
+		yield return () => (Int256.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt256.Int256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt256)>> ConvertToTruncatingUInt256TestData()
+	{
+		yield return () => (Int256.MinValue, new UInt256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (Int256.NegativeOne, UInt256.MaxValue);
+		yield return () => (Int256.One, UInt256.One);
+		yield return () => (Int256.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt256.Int256MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, UInt512)>> ConvertToCheckedUInt512TestData()
+	{
+		yield return () => (Int256.One, UInt512.One);
+		yield return () => (Int256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt512.Int256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt512)>> ConvertToSaturatingUInt512TestData()
+	{
+		yield return () => (Int256.MinValue, UInt512.Zero);
+		yield return () => (Int256.One, UInt512.One);
+		yield return () => (Int256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt512.Int256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, UInt512)>> ConvertToTruncatingUInt512TestData()
+	{
+		yield return () => (Int256.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (Int256.NegativeOne, UInt512.MaxValue);
+		yield return () => (Int256.One, UInt512.One);
+		yield return () => (Int256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int256.MaxValue, UInt512.Int256MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		yield return () => (Int256.MinValue, sbyte.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.MaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int256, short)>> ConvertToCheckedInt16TestData()
+	{
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, short)>> ConvertToSaturatingInt16TestData()
+	{
+		yield return () => (Int256.MinValue, short.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, short)>> ConvertToTruncatingInt16TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int256, int)>> ConvertToCheckedInt32TestData()
+	{
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, int)>> ConvertToSaturatingInt32TestData()
+	{
+		yield return () => (Int256.MinValue, int.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, int)>> ConvertToTruncatingInt32TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int256, long)>> ConvertToCheckedInt64TestData()
+	{
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, long)>> ConvertToSaturatingInt64TestData()
+	{
+		yield return () => (Int256.MinValue, long.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, long)>> ConvertToTruncatingInt64TestData()
+	{
+		yield return () => (Int256.MinValue, 0);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int256, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, Int128.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		yield return () => (Int256.MinValue, Int128.MinValue);
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, Int128.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		yield return () => (Int256.MinValue, Int128.Zero);
+		yield return () => (Int256.MinValue, Int128.MinValue);
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, Int128.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, Int128.NegativeOne);
+	}
+
+	public static IEnumerable<Func<(Int256, Int512)>> ConvertToCheckedInt512TestData()
+	{
+		yield return () => (Int256.MinValue, Int512.Int256MinValue);
+		yield return () => (Int256.Int128MinValue, Int512.Int128MinValue);
+		yield return () => (Int256.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Int256.One, Int512.One);
+		yield return () => (Int256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (Int256.MaxValue, Int512.Int256MaxValue);
+		
+		yield return () => (Int256.Parse("-465182250000"), Int512.Parse("-465182250000"));
+	}
+	
+	public static IEnumerable<Func<(Int256, Int512)>> ConvertToSaturatingInt512TestData()
+	{
+		yield return () => (Int256.MinValue, Int512.Int256MinValue);
+		yield return () => (Int256.Int128MinValue, Int512.Int128MinValue);
+		yield return () => (Int256.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Int256.One, Int512.One);
+		yield return () => (Int256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (Int256.MaxValue, Int512.Int256MaxValue);
+		
+		yield return () => (Int256.Parse("-465182250000"), Int512.Parse("-465182250000"));
+	}
+	
+	public static IEnumerable<Func<(Int256, Int512)>> ConvertToTruncatingInt512TestData()
+	{
+		yield return () => (Int256.MinValue, Int512.Int256MinValue);
+		yield return () => (Int256.Int128MinValue, Int512.Int128MinValue);
+		yield return () => (Int256.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Int256.One, Int512.One);
+		yield return () => (Int256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (Int256.MaxValue, Int512.Int256MaxValue);
+		
+		yield return () => (Int256.Parse("-465182250000"), Int512.Parse("-465182250000"));
+	}
+	
+	public static IEnumerable<Func<(Int256, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		yield return () => (Int256.MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, BigInteger.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+	}
+
+	public static IEnumerable<Func<(Int256, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		yield return () => (Int256.MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, BigInteger.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+	}
+
+	public static IEnumerable<Func<(Int256, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		yield return () => (Int256.MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int256.Int128MinValue, Int128.MinValue);
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, BigInteger.One);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		yield return () => (Int256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int256.MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+	}
+
+	public static IEnumerable<Func<(Int256, Half)>> ConvertToCheckedHalfTestData()
+	{
+		yield return () => (Int256.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int256.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int256.One, Half.One);
+		yield return () => (Int256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, (Half)short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		yield return () => (Int256.MinValue, Half.MinValue);
+		yield return () => (Int256.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int256.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int256.One, Half.One);
+		yield return () => (Int256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (Int256.MaxValue, Half.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		yield return () => (Int256.MinValue, Half.MinValue);
+		yield return () => (Int256.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int256.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int256.One, Half.One);
+		yield return () => (Int256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (Int256.MaxValue, Half.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, float)>> ConvertToCheckedSingleTestData()
+	{
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1f);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, float)>> ConvertToSaturatingSingleTestData()
+	{
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1f);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, float)>> ConvertToTruncatingSingleTestData()
+	{
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1f);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, double)>> ConvertToCheckedDoubleTestData()
+	{
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1d);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int256.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+	}
+	
+	public static IEnumerable<Func<(Int256, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1d);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int256.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+	}
+	
+	public static IEnumerable<Func<(Int256, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		yield return () => (Int256.Int64MinValue, long.MinValue);
+		yield return () => (Int256.Int32MinValue, int.MinValue);
+		yield return () => (Int256.Int16MinValue, short.MinValue);
+		yield return () => (Int256.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int256.One, 1d);
+		yield return () => (Int256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int256.Int16MaxValue, short.MaxValue);
+		yield return () => (Int256.Int32MaxValue, int.MaxValue);
+		yield return () => (Int256.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int256.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+	}
+
+	public static IEnumerable<Func<(Int256, Quad)>> ConvertToCheckedQuadTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int256.One, Quad.One);
+		yield return () => (Int256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Quad)>> ConvertToSaturatingQuadTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int256.One, Quad.One);
+		yield return () => (Int256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Quad)>> ConvertToTruncatingQuadTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int256.One, Quad.One);
+		yield return () => (Int256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Quad.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int256, Octo)>> ConvertToCheckedOctoTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int256.One, Octo.One);
+		yield return () => (Int256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Octo.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Octo)>> ConvertToSaturatingOctoTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int256.One, Octo.One);
+		yield return () => (Int256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Octo.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int256, Octo)>> ConvertToTruncatingOctoTestData()
+	{
+		yield return () => (Int256.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int256.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int256.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int256.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int256.One, Octo.One);
+		yield return () => (Int256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int256.Int64MaxValue, Octo.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(byte, Int256)>> ConvertFromCheckedByteTestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Int256)>> ConvertFromSaturatingByteTestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Int256)>> ConvertFromTruncatingByteTestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(ushort, Int256)>> ConvertFromCheckedUInt16TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Int256)>> ConvertFromSaturatingUInt16TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Int256)>> ConvertFromTruncatingUInt16TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(uint, Int256)>> ConvertFromCheckedUInt32TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Int256)>> ConvertFromSaturatingUInt32TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Int256)>> ConvertFromTruncatingUInt32TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+
+	public static IEnumerable<Func<(ulong, Int256)>> ConvertFromCheckedUInt64TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Int256)>> ConvertFromSaturatingUInt64TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Int256)>> ConvertFromTruncatingUInt64TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt128, Int256)>> ConvertFromCheckedUInt128TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int256.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Int256)>> ConvertFromSaturatingUInt128TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int256.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Int256)>> ConvertFromTruncatingUInt128TestData()
+	{
+		yield return () => (1, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int256.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(sbyte, Int256)>> ConvertFromCheckedSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Int256)>> ConvertFromSaturatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Int256)>> ConvertFromTruncatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(short, Int256)>> ConvertFromCheckedInt16TestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Int256)>> ConvertFromSaturatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Int256)>> ConvertFromTruncatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+	}
+
+	public static IEnumerable<Func<(int, Int256)>> ConvertFromCheckedInt32TestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Int256)>> ConvertFromSaturatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Int256)>> ConvertFromTruncatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+	}
+
+	public static IEnumerable<Func<(long, Int256)>> ConvertFromCheckedInt64TestData()
+	{
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Int256)>> ConvertFromSaturatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Int256)>> ConvertFromTruncatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int128, Int256)>> ConvertFromCheckedInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (Int128.One, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, Int256)>> ConvertFromSaturatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, Int256)>> ConvertFromTruncatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(BigInteger, Int256)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int256.MinValue);
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (BigInteger.One, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Int256)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819969"), Int256.MinValue);
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int256.MinValue);
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (BigInteger.One, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int256.MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Int256)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819969"), Int256.MaxValue);
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int256.MinValue);
+		yield return () => (Int128.MinValue, Int256.Int128MinValue);
+		yield return () => (long.MinValue, Int256.Int64MinValue);
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (BigInteger.One, Int256.One);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (long.MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int256.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int256.MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int256.MinValue);
+	}
+
+	public static IEnumerable<Func<(Half, Int256)>> ConvertFromCheckedHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (Half.One, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, Int256)>> ConvertFromSaturatingHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (Half.One, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, Int256)>> ConvertFromTruncatingHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (Half.One, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(float, Int256)>> ConvertFromCheckedSingleTestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1f, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, Int256)>> ConvertFromSaturatingSingleTestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1f, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, Int256)>> ConvertFromTruncatingSingleTestData()
+	{
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1f, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(double, Int256)>> ConvertFromCheckedDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1d, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, Int256)>> ConvertFromSaturatingDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1d, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, Int256)>> ConvertFromTruncatingDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int256.Int32MinValue);
+		yield return () => (short.MinValue, Int256.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int256.SByteMinValue);
+		yield return () => (1d, Int256.One);
+		yield return () => (byte.MaxValue, Int256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int256.SByteMaxValue);
+		yield return () => (short.MaxValue, Int256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int256.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int256.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int256.UInt32MaxValue);
+	}
+}
diff --git a/src/MissingValues.Tests/Data/Int512DataSources.cs b/src/MissingValues.Tests/Data/Int512DataSources.cs
new file mode 100644
index 0000000..39ae06c
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Int512DataSources.cs
@@ -0,0 +1,2564 @@
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using MissingValues.Tests.Data.Sources;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class Int512DataSources
+	: IMathOperatorsDataSource<Int512>,
+	IShiftOperatorsDataSource<Int512>,
+	IBitwiseOperatorsDataSource<Int512>,
+	IEqualityOperatorsDataSource<Int512>,
+	IComparisonOperatorsDataSource<Int512>,
+	INumberBaseDataSource<Int512>,
+	INumberDataSource<Int512>,
+	IBinaryNumberDataSource<Int512>,
+	IBinaryIntegerDataSource<Int512>
+{
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_AdditionTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.One, Int512.Zero, Int512.One);
+		yield return () => (Int512.One, Int512.One, new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 1, 1), 
+			new Int512(0, 0, 0, 0, 0, 0, 3, 0));
+		yield return () => (
+			new Int512(0, 0, 0, 1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(0, 0, 0, 1, 1, 1, 1, 1), 
+			new Int512(0, 0, 0, 3, 1, 1, 1, 0));
+		yield return () => (
+			new Int512(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(1, 1, 1, 1, 1, 1, 1, 1), 
+			new Int512(3, 1, 1, 1, 1, 1, 1, 0));
+		yield return () => (Int512.MaxValue, Int512.One, Int512.MinValue);
+		yield return () => (Int512.NegativeOne, Int512.One, Int512.Zero);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512, bool)>> op_CheckedAdditionTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero, false);
+		yield return () => (Int512.One, Int512.Zero, Int512.One, false);
+		yield return () => (Int512.One, Int512.One, new Int512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 1, 1), 
+			new Int512(0, 0, 0, 0, 0, 0, 3, 0), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(0, 0, 0, 1, 1, 1, 1, 1), 
+			new Int512(0, 0, 0, 3, 1, 1, 1, 0), 
+			false);
+		yield return () => (
+			new Int512(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(1, 1, 1, 1, 1, 1, 1, 1), 
+			new Int512(3, 1, 1, 1, 1, 1, 1, 0), 
+			false);
+		yield return () => (Int512.MaxValue, Int512.One, Int512.MinValue, true);
+		yield return () => (Int512.NegativeOne, Int512.One, Int512.Zero, false);
+		yield return () => (Int512.MinValue, Int512.NegativeOne, Int512.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_CheckedDecrementTestData()
+	{
+		yield return () => (Int512.Zero, Int512.NegativeOne, false);
+		yield return () => (Int512.One, Int512.Zero, false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, 2), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 1, 0, 0, 0), 
+			new Int512(0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 1, 0, 0, 0, 0), 
+			new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			false);
+		yield return () => (
+			new Int512(1, 0, 0, 0, 0, 0, 0, 0), 
+			new Int512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			false);
+		yield return () => (Int512.MinValue, Int512.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_CheckedIncrementTestData()
+	{
+		yield return () => (Int512.Zero, Int512.One, false);
+		yield return () => (Int512.One, new Int512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (Int512.MaxValue, Int512.Zero, true);
+		yield return () => (Int512.NegativeOne, Int512.Zero, false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			false);
+		yield return () => (
+			new Int512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(1, 0, 0, 0, 0, 0, 0, 0), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(0, 0, 0, 1, 0, 0, 0, 0), 
+			false);
+		yield return () => (
+			new Int512(unchecked((ulong)-123456789), 987654321, 555555555, 444444444, 333333333, 222222222, 111111111, 999999999), 
+			new Int512(unchecked((ulong)-123456789), 987654321, 555555555, 444444444, 333333333, 222222222, 111111111, 1000000000), 
+			false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512, bool)>> op_CheckedMultiplyTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero, false);
+		yield return () => (Int512.Zero, Int512.One, Int512.Zero, false);
+		yield return () => (Int512.One, Int512.One, Int512.One, false);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne, false);
+		yield return () => (Int512.NegativeOne, Int512.NegativeOne, Int512.One, false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 0, 3), new Int512(0, 0, 0, 0, 0, 0, 0, 6), false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue - 1), false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFE, 0x0000_0000_0000_0001),
+			false
+		);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000),
+			false
+		);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0), 
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000),
+			false
+		);
+		yield return () => (
+			Int512.MaxValue, 
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1), 
+			Int512.MaxValue,
+			false
+		);
+		yield return () => (
+			Int512.MaxValue, 
+			new Int512(0, 0, 0, 0, 0, 0, 0, 2), 
+			default,
+			true
+		);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512, bool)>> op_CheckedSubtractionTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero, false);
+		yield return () => (Int512.One, Int512.Zero, Int512.One, false);
+		yield return () => (Int512.One, Int512.One, Int512.Zero, false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, 2), 
+			Int512.One, 
+			Int512.One, 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			false);
+		yield return () => (
+			new Int512(0, 0, 0, 1, 0, 0, 0, 0), 
+			new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1), 
+			false);
+		yield return () => (Int512.MinValue, Int512.One, Int512.MaxValue, true);
+		yield return () => (Int512.MaxValue, Int512.NegativeOne, Int512.MinValue, true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> op_DecrementTestData()
+	{
+		yield return () => (Int512.Zero, Int512.NegativeOne);
+		yield return () => (Int512.One, Int512.Zero);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 1, 0, 0), new Int512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new Int512(0, 0, 0, 0, 1, 0, 0, 0), new Int512(0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new Int512(1, 0, 0, 0, 0, 0, 0, 0), new Int512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (Int512.MinValue, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_DivisionTestData()
+	{
+		yield return () => (Int512.Zero, Int512.One, Int512.Zero);
+		yield return () => (Int512.One, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.NegativeOne, Int512.One, Int512.NegativeOne);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 4), new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (Int512.MaxValue, Int512.One, Int512.MaxValue);
+		yield return () => (Int512.MinValue, Int512.One, Int512.MinValue);
+		yield return () => (Int512.Zero, Int512.MaxValue, Int512.Zero);
+		yield return () => (Int512.MaxValue, Int512.MaxValue, Int512.One);
+		yield return () => (Int512.MinValue, Int512.MinValue, Int512.One);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), new Int512(0, 0, 0, 0, 0, 1, 0, 0), Int512.Zero);
+		yield return () => (
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000)
+			);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> op_IncrementTestData()
+	{
+		yield return () => (Int512.Zero, Int512.One);
+		yield return () => (Int512.One, new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (Int512.MaxValue, Int512.MinValue);
+		yield return () => (Int512.NegativeOne, Int512.Zero);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => (
+			new Int512(unchecked((ulong)-123456789), 987654321, 555555555, 444444444, 333333333, 222222222, 111111111, 999999999), 
+			new Int512(unchecked((ulong)-123456789), 987654321, 555555555, 444444444, 333333333, 222222222, 111111111, 1000000000));
+		yield return () => (new Int512(0, 0, 0, 0, 0x8000000000000000, 0, 0, 0),new Int512(0, 0, 0, 0, 0x8000000000000000, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_ModulusTestData()
+	{
+		yield return () => (Int512.Zero, Int512.One, Int512.Zero);
+		yield return () => (Int512.One, Int512.One, Int512.Zero);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 123456789), Int512.One, Int512.Zero);
+		yield return () => (Int512.MaxValue, Int512.MaxValue, Int512.Zero);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), new Int512(0, 0, 0, 0, 0, 1, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 10), new Int512(0, 0, 0, 0, 0, 0, 0, 3), new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 15), new Int512(0, 0, 0, 0, 0, 0, 0, 5), Int512.Zero);
+		yield return () => (Int512.NegativeOne, new Int512(0, 0, 0, 0, 0, 0, 0, 2), Int512.NegativeOne);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 7), Int512.NegativeOne, Int512.Zero);
+		yield return () => (Int512.MaxValue, new Int512(0, 0, 0, 0, 0, 0, 0, 123456789), new Int512(0, 0, 0, 0, 0, 0, 0, 29802988));
+		yield return () => (new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0040, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_000F, 0xEE50_B702_5C36_A080, 0x2F23_6D04_753D_5B48, 0xE800_0000_0000_0000), new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x46BD_23F6_8F25_7DFF, 0x4372_4BEE_2B0A_92DC, 0x6000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_MultiplyTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.Zero, Int512.One, Int512.Zero);
+		yield return () => (Int512.One, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.NegativeOne, Int512.NegativeOne, Int512.One);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 0, 3), new Int512(0, 0, 0, 0, 0, 0, 0, 6));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue - 1));
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			new Int512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFE, 0x0000_0000_0000_0001)
+			);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0, 0, 0, 0, 0, 0, 1, 0), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)
+			);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0), 
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0), 
+			new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000)
+			);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_SubtractionTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.One, Int512.Zero, Int512.One);
+		yield return () => (Int512.One, Int512.One, Int512.Zero);
+		yield return () => (Int512.Zero, Int512.One, Int512.NegativeOne);
+		yield return () => (
+			Int512.MaxValue, 
+			Int512.One, 
+			new Int512(long.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue - 1));
+		yield return () => (Int512.MinValue, Int512.One, Int512.MaxValue);
+		yield return () => (
+			Int512.MinValue, 
+			Int512.NegativeOne, 
+			new Int512(unchecked((ulong)long.MinValue), 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (
+			new Int512(1, 2, 3, 4, 5, 6, 7, 8),
+			new Int512(0, 1, 2, 3, 4, 5, 6, 7),
+			new Int512(1, 1, 1, 1, 1, 1, 1, 1));
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, 0),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(unchecked((ulong)-1), ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> op_UnaryNegationTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_CheckedUnaryNegationTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, int, Int512)>> op_ShiftLeftTestData()
+	{
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 0, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 1, new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 63, new Int512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 64, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 128, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 256, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 511, new Int512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 512, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 513, new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+	}
+
+	public static IEnumerable<Func<(Int512, int, Int512)>> op_ShiftRightTestData()
+	{
+		yield return () => (Int512.Zero, 100, Int512.Zero);
+		yield return () => (Int512.One, 0, Int512.One);
+		yield return () => (new Int512(1, 0, 0, 0, 0, 0, 0, 0), 64, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(1, 0, 0, 0, 0, 0, 0, 0), 128, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(1, 0, 0, 0, 0, 0, 0, 0), 192, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => (new Int512(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0, 0, 0, 0, 0), 031, new Int512(0b1111111111111111111111111111111100000000000000000000000000000000, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0, 0, 0, 0, 0), 127, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0, 0, 0, 0, 0), 255, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0, 0, 0));
+		yield return () => (new Int512(0b1000000000000000000000000000000000000000000000000000000000000000, 0, 0, 0, 0, 0, 0, 0), 511, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => (Int512.One, 512, Int512.One);
+	}
+
+	public static IEnumerable<Func<(Int512, int, Int512)>> op_UnsignedShiftRightTestData()
+	{
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 0, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), 1, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000), 63, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), 64, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 1, 0, 0), 128, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 1, 0, 0, 0, 0), 256, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0), 511, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 512, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), 513, new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_BitwiseAndTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.Zero, Int512.MaxValue, Int512.Zero);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), Int512.MaxValue, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_BitwiseOrTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.Zero, Int512.MaxValue, Int512.MaxValue);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), Int512.MaxValue, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> op_BitwiseXorTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, Int512.Zero);
+		yield return () => (Int512.Zero, Int512.MaxValue, Int512.MaxValue);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), Int512.Zero);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> op_OnesComplementTestData()
+	{
+		yield return () => (Int512.Zero, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (Int512.MaxValue, new Int512(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (new Int512(0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555), new Int512(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA));
+		yield return () => (new Int512(0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new Int512(~0x0123456789ABCDEFU, ~0xFEDCBA9876543210U, ~0x0F0F0F0F0F0F0F0FU, ~0xF0F0F0F0F0F0F0F0U, ~0x0123456789ABCDEFU, ~0xFEDCBA9876543210U, ~0x0F0F0F0F0F0F0F0FU, ~0xF0F0F0F0F0F0F0F0U));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_EqualityTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_InequalityTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_GreaterThanOrEqualTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_GreaterThanTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_LessThanOrEqualTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, bool)>> op_LessThanTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero, false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 6, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 9), new Int512(1, 2, 3, 4, 5, 6, 7, 1), false);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new Int512(1, 2, 2, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(2, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new Int512(1, 1, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> AbsTestData()
+	{
+		yield return () => (Int512.Zero, Int512.Zero);
+		yield return () => (Int512.One, Int512.One);
+		yield return () => (Int512.NegativeOne, Int512.One);
+		yield return () => (Int512.MinValue + Int512.One, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsCanonicalTestData()
+	{
+		yield return () => (Int512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsComplexNumberTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsEvenIntegerTestData()
+	{
+		yield return () => (Int512.Zero, true);
+		yield return () => (Int512.One, false);
+		yield return () => (Int512.NegativeOne, false);
+		yield return () => (new Int512(0, 0, 0, 2), true);
+		yield return () => (new Int512(0, 0, 0, 3), false);
+		yield return () => (new Int512(0, 0, 0, 4), true);
+		yield return () => (new Int512(0, 0, 0, 6), true);
+		yield return () => (new Int512(0, 0, 0, 8), true);
+		yield return () => (new Int512(0, 0, 0, 16), true);
+		yield return () => (-new Int512(0, 0, 0, 2), true);
+		yield return () => (-new Int512(0, 0, 0, 3), false);
+		yield return () => (-new Int512(0, 0, 0, 4), true);
+		yield return () => (-new Int512(0, 0, 0, 6), true);
+		yield return () => (-new Int512(0, 0, 0, 8), true);
+		yield return () => (-new Int512(0, 0, 0, 16), true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsFiniteTestData()
+	{
+		yield return () => (Int512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsImaginaryNumberTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsInfinityTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsIntegerTestData()
+	{
+		yield return () => (Int512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsNaNTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsNegativeTestData()
+	{
+		yield return () => (Int512.Zero, false);
+		yield return () => (Int512.One, false);
+		yield return () => (Int512.MaxValue, false);
+		yield return () => (Int512.NegativeOne, true);
+		yield return () => (-Int512.One, true);
+		yield return () => (-Int512.MaxValue, true);
+		yield return () => (Int512.MinValue, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsNegativeInfinityTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsNormalTestData()
+	{
+		yield return () => (Int512.Zero, false);
+		yield return () => (Int512.One, true);
+		yield return () => (Int512.NegativeOne, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsOddIntegerTestData()
+	{
+		yield return () => (Int512.Zero, false);
+		yield return () => (Int512.One, true);
+		yield return () => (Int512.NegativeOne, true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 3), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 4), false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 6), false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 8), false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 16), false);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 3), true);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 4), false);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 6), false);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 8), false);
+		yield return () => (-new Int512(0, 0, 0, 0, 0, 0, 0, 16), false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsPositiveTestData()
+	{
+		yield return () => (Int512.Zero, true);
+		yield return () => (Int512.One, true);
+		yield return () => (Int512.MaxValue, true);
+		yield return () => (Int512.NegativeOne, false);
+		yield return () => (-Int512.One, false);
+		yield return () => (-Int512.MaxValue, false);
+		yield return () => (Int512.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsPositiveInfinityTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsRealNumberTestData()
+	{
+		yield return () => (Int512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsSubnormalTestData()
+	{
+		yield return () => (Int512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsZeroTestData()
+	{
+		yield return () => (Int512.Zero, true);
+		yield return () => (Int512.One, false);
+		yield return () => (Int512.NegativeOne, false);
+		yield return () => (Int512.MaxValue, false);
+		yield return () => (Int512.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MaxMagnitudeTestData()
+	{
+		yield return () => (Int512.MaxValue, 5, Int512.MaxValue);
+		yield return () => (Int512.One, 5, 5);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.One);
+		yield return () => (Int512.One, -2, -2);
+		yield return () => (Int512.NegativeOne, Int512.MaxValue, Int512.MaxValue);
+		yield return () => (Int512.MinValue, -2, Int512.MinValue);
+		yield return () => (Int512.MaxValue, Int512.MinValue, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MaxMagnitudeNumberTestData()
+	{
+		yield return () => (Int512.MaxValue, 5, Int512.MaxValue);
+		yield return () => (Int512.One, 5, 5);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.One);
+		yield return () => (Int512.One, -2, -2);
+		yield return () => (Int512.NegativeOne, Int512.MaxValue, Int512.MaxValue);
+		yield return () => (Int512.MinValue, -2, Int512.MinValue);
+		yield return () => (Int512.MaxValue, Int512.MinValue, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MinMagnitudeTestData()
+	{
+		yield return () => (Int512.MaxValue, 5, 5);
+		yield return () => (Int512.One, 5, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.One, -2, Int512.One);
+		yield return () => (Int512.NegativeOne, Int512.MaxValue, Int512.NegativeOne);
+		yield return () => (Int512.MinValue, -2, -2);
+		yield return () => (Int512.MaxValue, Int512.MinValue, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MinMagnitudeNumberTestData()
+	{
+		yield return () => (Int512.MaxValue, 5, 5);
+		yield return () => (Int512.One, 5, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.One, -2, Int512.One);
+		yield return () => (Int512.NegativeOne, Int512.MaxValue, Int512.NegativeOne);
+		yield return () => (Int512.MinValue, -2, -2);
+		yield return () => (Int512.MaxValue, Int512.MinValue, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512, Int512)>> MultiplyAddEstimateTestData()
+	{
+		yield return () => (Int512.One, Int512.One, Int512.One, 2);
+		yield return () => (Int512.One, Int512.Zero, Int512.One, Int512.One);
+		yield return () => (Int512.MaxValue, Int512.NegativeOne, Int512.NegativeOne, Int512.MinValue);
+		yield return () => (200, 100, 500, 20500);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new Int512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new Int512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), Int512.Parse("115792089237316195423570985008687907852929702298719625575994209400481361428480"));
+		yield return () => (new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int512(0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new Int512(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, Int512)>> ParseTestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.NegativeOne);
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656", NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047", NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000", NumberStyles.Number, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("1,000.0", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00", NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000", NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048", NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00", NumberStyles.Currency, Helper.CustomInfo, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, Int512)>> ParseSpanTestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.NegativeOne);
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("1,000.0".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000".ToCharArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048".ToCharArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, Int512)>> ParseUtf8TestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int128.MinValue);
+		yield return () => ("-9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, long.MinValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.NegativeOne);
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, Int512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		
+		yield return () => ("2.5E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 25_000_000_000);
+		yield return () => ("1E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, 10_000_000_000);
+		yield return () => ("1.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, Int512.One);
+		yield return () => ("1,000.0"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000);
+		yield return () => ("1,000,000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000);
+		yield return () => ("1,000,000,000.00"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000"u8.ToArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048"u8.ToArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, Int512)>> TryParseTestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808", NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.NegativeOne);
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047", NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MaxValue);
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10", NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000", NumberStyles.Number, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("1,000.0", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00", NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000", NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048", NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00", NumberStyles.Currency, Helper.CustomInfo, true, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, Int512)>> TryParseSpanTestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.NegativeOne);
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MaxValue);
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10".ToCharArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("1,000.0".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00".ToCharArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000".ToCharArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048".ToCharArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, true, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, Int512)>> TryParseUtf8TestData()
+	{
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MinValue);
+		yield return () => ("-57896044618658097711785492504343953926634992332820282019728792003956564819968"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Int256MinValue);
+		yield return () => ("-170141183460469231731687303715884105728"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int128.MinValue);
+		yield return () => ("-9223372036854775808"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, long.MinValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.NegativeOne);
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new Int512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, Int512.MaxValue);
+		yield return () => ("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, true, new Int512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, true, new Int512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("1E200"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.5E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 25_000_000_000);
+		yield return () => ("1E10"u8.ToArray(), NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, true, 10_000_000_000);
+		yield return () => ("1.000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, Int512.One);
+		yield return () => ("1,000.0"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000);
+		yield return () => ("1,000,000"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000);
+		yield return () => ("1,000,000,000.00"u8.ToArray(), NumberStyles.Number, CultureInfo.InvariantCulture, true, 1_000_000_000);
+		yield return () => ("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000"u8.ToArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048"u8.ToArray(), NumberStyles.Number, NumberFormatInfo.InvariantInfo, true, Int512.MinValue);
+		yield return () => ("$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, true, Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(Int512, string, IFormatProvider?, string)>> ToStringTestData()
+	{
+		yield return () => (Int512.Int256MaxValue, "e25", CultureInfo.InvariantCulture, "5.7896044618658097711785493e+76");
+		yield return () => (Int512.Int256MinValue, "e25", CultureInfo.InvariantCulture, "-5.7896044618658097711785493e+76");
+		yield return () => (Int512.MaxValue, "e25", CultureInfo.InvariantCulture, "6.7039039649712985497870125e+153");
+		yield return () => (Int512.MinValue, "e25", CultureInfo.InvariantCulture, "-6.7039039649712985497870125e+153");
+		yield return () => (Int512.MinValue, "F3", CultureInfo.InvariantCulture, "-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.000");
+		yield return () => (Int512.MinValue, "N", CultureInfo.InvariantCulture, "-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00");
+		yield return () => (Int512.MinValue, "C", Helper.CustomInfo, "$-6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00");
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512, Int512)>> ClampTestData()
+	{
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 2),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 4),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 2)
+		);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 4),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1)
+		);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(0, 0, 0, 0, 1, 0, 0, 0),
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0)
+		);
+		yield return () => (
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0),
+			new Int512(0, 0, 0, 0, 0, 0, 0, 1),
+			new Int512(1, 0, 0, 0, 0, 0, 0, 0),
+			new Int512(0, 0, 0, 0, 0, 1, 0, 0)
+		);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> CopySignTestData()
+	{
+		yield return () => (Int512.One, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.NegativeOne, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.NegativeOne, Int512.One, Int512.One);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MaxTestData()
+	{
+		yield return () => (Int512.One, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.One);
+		yield return () => (Int512.MinValue, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.Zero, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.MaxValue, Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MaxNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MinTestData()
+	{
+		yield return () => (Int512.One, Int512.One, Int512.One);
+		yield return () => (Int512.One, Int512.NegativeOne, Int512.NegativeOne);
+		yield return () => (Int512.MinValue, Int512.NegativeOne, Int512.MinValue);
+		yield return () => (Int512.Zero, Int512.One, Int512.Zero);
+		yield return () => (Int512.One, Int512.MaxValue, Int512.One);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Int512)>> MinNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(Int512, int)>> SignTestData()
+	{
+		yield return () => (Int512.Zero, 0);
+		yield return () => (Int512.MaxValue, 1);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.MinValue, -1);
+		yield return () => (Int512.NegativeOne, -1);
+	}
+
+	public static IEnumerable<Func<(Int512, bool)>> IsPow2TestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 4), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 8), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 16), true);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1UL << 63), true);
+		yield return () => (new Int512(0, 0, 0, 0, 1UL << 63, 0, 0, 0), true);
+		yield return () => (new Int512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), false);
+		yield return () => (Int512.Zero, false);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 3), false);
+		yield return () => (Int512.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> Log2TestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 2), new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 4), new Int512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 8), new Int512(0, 0, 0, 0, 0, 0, 0, 3));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1UL << 63), new Int512(0, 0, 0, 0, 0, 0, 0, 63));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1UL << 5, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 69));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 1UL << 42, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 170));
+		yield return () => (new Int512(0, 0, 0, 0, 1UL << 13, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 205));
+		yield return () => (new Int512(0, 0, 0, 0, 1UL << 63, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 255));
+		yield return () => (new Int512(1UL << 62, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 510));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512, Pair<Int512>)>> DivRemTestData()
+	{
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(0, 0, 0, 0, 0, 0, 0, 1), (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 8), (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), new Int512(1, 2, 3, 4, 5, 6, 7, 9), (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new Int512(1, 2, 3, 4, 5, 6, 7, 8)));
+		yield return () => (Int512.MaxValue, new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), (new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
+		yield return () => (Int512.MaxValue, new Int512(0, 0, 0, 1, 0, 0, 0, 0), (new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new Int512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> LeadingZeroCountTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 512));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 511));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 447));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1UL << 36, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 411));
+		yield return () => (new Int512(0, 0, 0, 1, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 255));
+		yield return () => (new Int512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> PopCountTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (Int512.MaxValue, new Int512(0, 0, 0, 0, 0, 0, 0, 511));
+		yield return () => (new Int512(ulong.MaxValue, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 64));
+		yield return () => (new Int512(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), new Int512(0, 0, 0, 0, 0, 0, 0, 256));
+		yield return () => (new Int512(0, 0, 0, 0, 1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60), new Int512(0, 0, 0, 0, 0, 0, 0, 4));
+		yield return () => (new Int512(1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60, 1UL << 59, 1UL << 58, 1UL << 57, 1UL << 56), new Int512(0, 0, 0, 0, 0, 0, 0, 8));
+	}
+
+	public static IEnumerable<Func<(byte[], bool, Int512)>> ReadBigEndianTestData()
+	{
+		yield return () => ([], true, Int512.Zero);
+		yield return () => ([0x01], true, Int512.One);
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			Array.Fill(array, byte.MaxValue);
+			return (array, false, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[67];
+			for (int i = 0; i < 67; i++)
+				array[i] = byte.MaxValue;
+			return (array, false, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () => ([0x12, 0x34], true, new Int512(0, 0, 0, 0, 0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			array[0] = 0x80;
+			return (array, false, new Int512(1UL << 63, 0, 0, 0, 0, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(byte[], bool, Int512)>> ReadLittleEndianTestData()
+	{
+		yield return () => ([], true, Int512.Zero);
+		yield return () => ([0x01], true, Int512.One);
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			Array.Fill(array, byte.MaxValue);
+			return (array, false, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[67];
+			for (int i = 0; i < 67; i++)
+				array[i] = byte.MaxValue;
+			return (array, false, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		};
+		yield return () => ([0x34, 0x12], true, new Int512(0, 0, 0, 0, 0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			array[63] = 0x80;
+			return (array, false, new Int512(1UL << 63, 0, 0, 0, 0, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(Int512, int, Int512)>> RotateLeftTestData()
+	{
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 0, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 512, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0), 64, new Int512(0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0));
+		yield return () => (new Int512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0), 64, new Int512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new Int512(0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0, 0), 128, new Int512(0, 0, 0x8000_0000_0000_0000, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(Int512, int, Int512)>> RotateRightTestData()
+	{
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 0, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(1, 2, 3, 4, 5, 6, 7, 8), 512, new Int512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0), 64, new Int512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000), 64, new Int512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0, 0), 128, new Int512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(Int512, Int512)>> TrailingZeroCountTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 512));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), new Int512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 64));
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 1UL << 36, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 100));
+		yield return () => (new Int512(0, 0, 0, 1, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 256));
+		yield return () => (new Int512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), new Int512(0, 0, 0, 0, 0, 0, 0, 511));
+	}
+
+	public static IEnumerable<Func<(Int512, int)>> GetByteCountTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), Unsafe.SizeOf<Int512>());
+	}
+
+	public static IEnumerable<Func<(Int512, int)>> GetShortestBitLengthTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), 0);
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 1), 1);
+		yield return () => (new Int512(0, 0, 0, 0, 1, 0, 0, 0), 193);
+		yield return () => (new Int512(1, 0, 0, 0, 0, 0, 0, 0), 449);
+		yield return () => (Int512.MaxValue, 511);
+		yield return () => (new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), 1);
+	}
+
+	public static IEnumerable<Func<(Int512, byte[], int)>> WriteBigEndianTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new byte[64], Unsafe.SizeOf<Int512>());
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 63; i++)
+				buffer[i] = 0;
+
+			buffer[63] = 1;
+			
+			return (new Int512(0, 0, 0, 0, 0, 0, 0, 1), buffer, Unsafe.SizeOf<Int512>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 64; i++)
+				buffer[i] = 0xFF;
+			
+			return (new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), buffer, Unsafe.SizeOf<Int512>());
+		};
+	}
+
+	public static IEnumerable<Func<(Int512, byte[], int)>> WriteLittleEndianTestData()
+	{
+		yield return () => (new Int512(0, 0, 0, 0, 0, 0, 0, 0), new byte[64], Unsafe.SizeOf<Int512>());
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			buffer[0] = 1;
+			for (int i = 1; i < 64; i++)
+				buffer[i] = 0;
+			
+			return (new Int512(0, 0, 0, 0, 0, 0, 0, 1), buffer, Unsafe.SizeOf<Int512>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 64; i++)
+				buffer[i] = 0xFF;
+			
+			return (new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), buffer, Unsafe.SizeOf<UInt512>());
+		};
+	}
+	
+	public static IEnumerable<Func<(Int512, byte)>> ConvertToCheckedByteTestData()
+	{
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, byte)>> ConvertToSaturatingByteTestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.MaxValue, byte.MaxValue);
+		yield return () => (Int512.ByteMaxValue + Int512.One, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, byte)>> ConvertToTruncatingByteTestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.NegativeOne, 0xFF);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.MaxValue, byte.MaxValue);
+		yield return () => (Int512.ByteMaxValue + Int512.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int512, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt16MaxValue + Int512.One, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.NegativeOne, 0xFFFF);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt16MaxValue + Int512.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int512, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt32MaxValue + Int512.One, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.NegativeOne, 0xFFFF_FFFF);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt32MaxValue + Int512.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int512, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int512.MaxValue, ulong.MaxValue);
+		yield return () => (Int512.UInt64MaxValue + Int512.One, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.NegativeOne, 0xFFFF_FFFF_FFFF_FFFF);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int512.MaxValue, ulong.MaxValue);
+		yield return () => (Int512.UInt64MaxValue + Int512.One, 0);
+	}
+
+	public static IEnumerable<Func<(Int512, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		yield return () => (Int512.One, UInt128.One);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		yield return () => (Int512.MinValue, UInt128.Zero);
+		yield return () => (Int512.One, UInt128.One);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (Int512.MaxValue, UInt128.MaxValue);
+		yield return () => (Int512.UInt128MaxValue + Int512.One, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		yield return () => (Int512.MinValue, UInt128.Zero);
+		yield return () => (Int512.NegativeOne, new UInt128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (Int512.One, UInt128.One);
+		yield return () => (Int512.ByteMaxValue, byte.MaxValue);
+		yield return () => (Int512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Int512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Int512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (Int512.MaxValue, UInt128.MaxValue);
+		yield return () => (Int512.UInt128MaxValue + Int512.One, UInt128.Zero);
+	}
+
+	public static IEnumerable<Func<(Int512, UInt256)>> ConvertToCheckedUInt256TestData()
+	{
+		yield return () => (Int512.One, UInt256.One);
+		yield return () => (Int512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt256)>> ConvertToSaturatingUInt256TestData()
+	{
+		yield return () => (Int512.MinValue, UInt256.Zero);
+		yield return () => (Int512.One, UInt256.One);
+		yield return () => (Int512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt256)>> ConvertToTruncatingUInt256TestData()
+	{
+		yield return () => (Int512.MinValue, UInt256.Zero);
+		yield return () => (Int512.NegativeOne, UInt256.MaxValue);
+		yield return () => (Int512.One, UInt256.One);
+		yield return () => (Int512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, UInt512)>> ConvertToCheckedUInt512TestData()
+	{
+		yield return () => (Int512.One, UInt512.One);
+		yield return () => (Int512.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt512.UInt256MaxValue);
+		yield return () => (Int512.MaxValue, UInt512.Int512MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt512)>> ConvertToSaturatingUInt512TestData()
+	{
+		yield return () => (Int512.MinValue, UInt512.Zero);
+		yield return () => (Int512.One, UInt512.One);
+		yield return () => (Int512.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt512.UInt256MaxValue);
+		yield return () => (Int512.MaxValue, UInt512.Int512MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, UInt512)>> ConvertToTruncatingUInt512TestData()
+	{
+		yield return () => (Int512.MinValue, new UInt512(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (Int512.NegativeOne, UInt512.MaxValue);
+		yield return () => (Int512.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Int512.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Int512.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Int512.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Int512.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (Int512.UInt256MaxValue, UInt512.UInt256MaxValue);
+		yield return () => (Int512.MaxValue, UInt512.Int512MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		yield return () => (Int512.MinValue, sbyte.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.MaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int512, short)>> ConvertToCheckedInt16TestData()
+	{
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, short)>> ConvertToSaturatingInt16TestData()
+	{
+		yield return () => (Int512.MinValue, short.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, short)>> ConvertToTruncatingInt16TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int512, int)>> ConvertToCheckedInt32TestData()
+	{
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, int)>> ConvertToSaturatingInt32TestData()
+	{
+		yield return () => (Int512.MinValue, int.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, int)>> ConvertToTruncatingInt32TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int512, long)>> ConvertToCheckedInt64TestData()
+	{
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, long)>> ConvertToSaturatingInt64TestData()
+	{
+		yield return () => (Int512.MinValue, long.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, long)>> ConvertToTruncatingInt64TestData()
+	{
+		yield return () => (Int512.MinValue, 0);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.MaxValue, -1);
+	}
+
+	public static IEnumerable<Func<(Int512, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, Int128.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		yield return () => (Int512.MinValue, Int128.MinValue);
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, Int128.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int512.MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		yield return () => (Int512.MinValue, Int128.Zero);
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, Int128.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int512.MaxValue, Int128.NegativeOne);
+	}
+
+	public static IEnumerable<Func<(Int512, Int256)>> ConvertToCheckedInt256TestData()
+	{
+		yield return () => (Int512.Int256MinValue, Int256.MinValue);
+		yield return () => (Int512.Int128MinValue, Int256.Int128MinValue);
+		yield return () => (Int512.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Int512.One, Int256.One);
+		yield return () => (Int512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (Int512.Int256MaxValue, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Int256)>> ConvertToSaturatingInt256TestData()
+	{
+		yield return () => (Int512.MinValue, Int256.MinValue);
+		yield return () => (Int512.Int256MinValue, Int256.MinValue);
+		yield return () => (Int512.Int128MinValue, Int256.Int128MinValue);
+		yield return () => (Int512.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Int512.One, Int256.One);
+		yield return () => (Int512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (Int512.Int256MaxValue, Int256.MaxValue);
+		yield return () => (Int512.MaxValue, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Int256)>> ConvertToTruncatingInt256TestData()
+	{
+		yield return () => (Int512.MinValue, Int256.Zero);
+		yield return () => (Int512.Int256MinValue, Int256.MinValue);
+		yield return () => (Int512.Int128MinValue, Int256.Int128MinValue);
+		yield return () => (Int512.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Int512.One, Int256.One);
+		yield return () => (Int512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (Int512.Int256MaxValue, Int256.MaxValue);
+		yield return () => (Int512.MaxValue, Int256.NegativeOne);
+	}
+	
+	public static IEnumerable<Func<(Int512, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		yield return () => (Int512.MinValue, BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
+		yield return () => (Int512.Int256MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, BigInteger.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int512.Int256MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+		yield return () => (Int512.MaxValue, BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
+	}
+
+	public static IEnumerable<Func<(Int512, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		yield return () => (Int512.MinValue, BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
+		yield return () => (Int512.Int256MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, BigInteger.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int512.Int256MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+		yield return () => (Int512.MaxValue, BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
+	}
+
+	public static IEnumerable<Func<(Int512, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		yield return () => (Int512.MinValue, BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"));
+		yield return () => (Int512.Int256MinValue, BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"));
+		yield return () => (Int512.Int128MinValue, Int128.MinValue);
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, BigInteger.One);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		yield return () => (Int512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (Int512.Int256MaxValue, BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"));
+		yield return () => (Int512.MaxValue, BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"));
+	}
+
+	public static IEnumerable<Func<(Int512, Half)>> ConvertToCheckedHalfTestData()
+	{
+		yield return () => (Int512.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int512.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int512.One, Half.One);
+		yield return () => (Int512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, (Half)short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		yield return () => (Int512.MinValue, Half.MinValue);
+		yield return () => (Int512.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int512.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int512.One, Half.One);
+		yield return () => (Int512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (Int512.MaxValue, Half.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		yield return () => (Int512.MinValue, Half.MinValue);
+		yield return () => (Int512.Int16MinValue, (Half)short.MinValue);
+		yield return () => (Int512.SByteMinValue, (Half)sbyte.MinValue);
+		yield return () => (Int512.One, Half.One);
+		yield return () => (Int512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (Int512.MaxValue, Half.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, float)>> ConvertToCheckedSingleTestData()
+	{
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1f);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, float)>> ConvertToSaturatingSingleTestData()
+	{
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1f);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, float)>> ConvertToTruncatingSingleTestData()
+	{
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1f);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, double)>> ConvertToCheckedDoubleTestData()
+	{
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1d);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+	
+	public static IEnumerable<Func<(Int512, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1d);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+		yield return () => (Int512.Parse("-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+	
+	public static IEnumerable<Func<(Int512, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		yield return () => (Int512.Int64MinValue, long.MinValue);
+		yield return () => (Int512.Int32MinValue, int.MinValue);
+		yield return () => (Int512.Int16MinValue, short.MinValue);
+		yield return () => (Int512.SByteMinValue, sbyte.MinValue);
+		yield return () => (Int512.One, 1d);
+		yield return () => (Int512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Int512.Int16MaxValue, short.MaxValue);
+		yield return () => (Int512.Int32MaxValue, int.MaxValue);
+		yield return () => (Int512.Int64MaxValue, long.MaxValue);
+		
+		yield return () => (Int512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("-781377183594418599030564404241984000000000000000000"),
+			-781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (Int512.Parse("693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+		yield return () => (Int512.Parse("-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			-693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+
+	public static IEnumerable<Func<(Int512, Quad)>> ConvertToCheckedQuadTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int512.One, Quad.One);
+		yield return () => (Int512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Quad)>> ConvertToSaturatingQuadTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int512.One, Quad.One);
+		yield return () => (Int512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Quad)>> ConvertToTruncatingQuadTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Quad.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Quad.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Quad.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Quad.SByteMinValue);
+		yield return () => (Int512.One, Quad.One);
+		yield return () => (Int512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Quad.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int512, Octo)>> ConvertToCheckedOctoTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int512.One, Octo.One);
+		yield return () => (Int512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Octo.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Octo)>> ConvertToSaturatingOctoTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int512.One, Octo.One);
+		yield return () => (Int512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Octo.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int512, Octo)>> ConvertToTruncatingOctoTestData()
+	{
+		yield return () => (Int512.Int64MinValue, Octo.Int64MinValue);
+		yield return () => (Int512.Int32MinValue, Octo.Int32MinValue);
+		yield return () => (Int512.Int16MinValue, Octo.Int16MinValue);
+		yield return () => (Int512.SByteMinValue, Octo.SByteMinValue);
+		yield return () => (Int512.One, Octo.One);
+		yield return () => (Int512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (Int512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (Int512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (Int512.Int64MaxValue, Octo.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(byte, Int512)>> ConvertFromCheckedByteTestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Int512)>> ConvertFromSaturatingByteTestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Int512)>> ConvertFromTruncatingByteTestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(ushort, Int512)>> ConvertFromCheckedUInt16TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Int512)>> ConvertFromSaturatingUInt16TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Int512)>> ConvertFromTruncatingUInt16TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(uint, Int512)>> ConvertFromCheckedUInt32TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Int512)>> ConvertFromSaturatingUInt32TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Int512)>> ConvertFromTruncatingUInt32TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+
+	public static IEnumerable<Func<(ulong, Int512)>> ConvertFromCheckedUInt64TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Int512)>> ConvertFromSaturatingUInt64TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Int512)>> ConvertFromTruncatingUInt64TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt128, Int512)>> ConvertFromCheckedUInt128TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int512.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Int512)>> ConvertFromSaturatingUInt128TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int512.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Int512)>> ConvertFromTruncatingUInt128TestData()
+	{
+		yield return () => (1, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Int512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Int512.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(sbyte, Int512)>> ConvertFromCheckedSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Int512)>> ConvertFromSaturatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Int512)>> ConvertFromTruncatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(short, Int512)>> ConvertFromCheckedInt16TestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Int512)>> ConvertFromSaturatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Int512)>> ConvertFromTruncatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+	}
+
+	public static IEnumerable<Func<(int, Int512)>> ConvertFromCheckedInt32TestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Int512)>> ConvertFromSaturatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Int512)>> ConvertFromTruncatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+	}
+
+	public static IEnumerable<Func<(long, Int512)>> ConvertFromCheckedInt64TestData()
+	{
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Int512)>> ConvertFromSaturatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Int512)>> ConvertFromTruncatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int128, Int512)>> ConvertFromCheckedInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Int128.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, Int512)>> ConvertFromSaturatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Int128.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, Int512)>> ConvertFromTruncatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Int128.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(BigInteger, Int512)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"), Int512.MinValue);
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int512.Int256MinValue);
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (BigInteger.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int512.Int256MaxValue);
+		yield return () => (BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"), Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Int512)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049"), Int512.MinValue);
+		yield return () => (BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"), Int512.MinValue);
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int512.Int256MinValue);
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (BigInteger.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int512.Int256MaxValue);
+		yield return () => (BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"), Int512.MaxValue);
+		yield return () => (BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"), Int512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Int512)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042049"), Int512.MaxValue);
+		yield return () => (BigInteger.Parse("-6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"), Int512.MinValue);
+		yield return () => (BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968"), Int512.Int256MinValue);
+		yield return () => (Int128.MinValue, Int512.Int128MinValue);
+		yield return () => (long.MinValue, Int512.Int64MinValue);
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (BigInteger.One, Int512.One);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (long.MaxValue, Int512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Int512.Int128MaxValue);
+		yield return () => (BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967"), Int512.Int256MaxValue);
+		yield return () => (BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042047"), Int512.MaxValue);
+		yield return () => (BigInteger.Parse("6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"), Int512.MinValue);
+	}
+
+	public static IEnumerable<Func<(Half, Int512)>> ConvertFromCheckedHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Half.One, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, Int512)>> ConvertFromSaturatingHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Half.One, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, Int512)>> ConvertFromTruncatingHalfTestData()
+	{
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (Half.One, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(float, Int512)>> ConvertFromCheckedSingleTestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1f, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, Int512)>> ConvertFromSaturatingSingleTestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1f, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, Int512)>> ConvertFromTruncatingSingleTestData()
+	{
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1f, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(double, Int512)>> ConvertFromCheckedDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1d, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, Int512)>> ConvertFromSaturatingDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1d, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, Int512)>> ConvertFromTruncatingDoubleTestData()
+	{
+		yield return () => (int.MinValue, Int512.Int32MinValue);
+		yield return () => (short.MinValue, Int512.Int16MinValue);
+		yield return () => (sbyte.MinValue, Int512.SByteMinValue);
+		yield return () => (1d, Int512.One);
+		yield return () => (byte.MaxValue, Int512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, Int512.SByteMaxValue);
+		yield return () => (short.MaxValue, Int512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, Int512.UInt16MaxValue);
+		yield return () => (int.MaxValue, Int512.Int32MaxValue);
+		yield return () => (uint.MaxValue, Int512.UInt32MaxValue);
+	}
+}
diff --git a/src/MissingValues.Tests/Data/OctoDataSources.cs b/src/MissingValues.Tests/Data/OctoDataSources.cs
new file mode 100644
index 0000000..6400451
--- /dev/null
+++ b/src/MissingValues.Tests/Data/OctoDataSources.cs
@@ -0,0 +1,1373 @@
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+using MissingValues.Tests.Data.Sources;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class OctoDataSources
+    : IMathOperatorsDataSource<Octo>,
+        IBitwiseOperatorsDataSource<Octo>,
+        IEqualityOperatorsDataSource<Octo>,
+        IComparisonOperatorsDataSource<Octo>,
+        INumberBaseDataSource<Octo>,
+        INumberDataSource<Octo>,
+        IBinaryNumberDataSource<Octo>,
+        IFloatingPointDataSource<Octo>,
+        IFloatingPointIeee754DataSource<Octo>
+{
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_AdditionTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, Octo.Two);
+	    yield return () => (Octo.One, Octo.NegativeOne, Octo.Zero);
+	    yield return () => (Octo.One, Octo.NegativeTwo, Octo.NegativeOne);
+	    yield return () => (Octo.One, Octo.Four, Octo.Five);
+	    yield return () => (Octo.Three, Octo.Two, Octo.Five);
+	    yield return () => (Octo.SmallestSubnormal, Octo.GreatestSubnormal, Values.CreateFloat<Octo>(0x0000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity);
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity);
+	    yield return () => (Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.PositiveInfinity);
+	    yield return () => (Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NegativeInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> op_DecrementTestData()
+    {
+	    yield return () => (Octo.NegativeOne, Octo.NegativeTwo);
+	    yield return () => (Octo.Zero, Octo.NegativeOne);
+	    yield return () => (Octo.One, Octo.Zero);
+	    yield return () => (Octo.Two, Octo.One);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_DivisionTestData()
+    {
+	    yield return () => (Octo.Ten, Octo.Ten, Octo.One);
+	    yield return () => (Octo.Hundred, Octo.Ten, Octo.Ten);
+	    yield return () => (Octo.NegativeThousand, Octo.Ten, Octo.NegativeHundred);
+	    yield return () => (Octo.Zero, Octo.Zero, Octo.NaN);
+	    yield return () => (Octo.One, Octo.Zero, Octo.PositiveInfinity);
+	    yield return () => (Octo.NegativeOne, Octo.Zero, Octo.NegativeInfinity);
+	    yield return () => (Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.NaN);
+	    yield return () => (Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NaN);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> op_IncrementTestData()
+    {
+	    yield return () => (Octo.NegativeTwo, Octo.NegativeOne);
+	    yield return () => (Octo.NegativeOne, Octo.Zero);
+	    yield return () => (Octo.Zero, Octo.One);
+	    yield return () => (Octo.One, Octo.Two);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_ModulusTestData()
+    {
+	    yield return () => (Octo.Two, Octo.Four, Octo.Two);
+	    yield return () => (Octo.Half, Octo.Four, Octo.Half);
+	    yield return () => (Octo.Four, Octo.Half, Octo.Zero);
+	    yield return () => (Octo.NegativeFour, Octo.Half, Octo.NegativeZero);
+	    yield return () => (Octo.NegativeFour, Octo.Thousand, Octo.NegativeFour);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_MultiplyTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.NegativeOne, Octo.NegativeOne);
+	    yield return () => (Octo.Ten, Octo.Ten, Octo.Hundred);
+	    yield return () => (Octo.NegativeHundred, Octo.Ten, Octo.NegativeThousand);
+	    yield return () => (Octo.NegativeTen, Octo.Hundred, Octo.NegativeThousand);
+	    yield return () => (Octo.Zero, Octo.NegativeThousand, Octo.NegativeZero);
+	    yield return () => (Octo.Zero, Octo.PositiveInfinity, Octo.NaN);
+	    yield return () => (Octo.NegativeZero, Octo.NegativeInfinity, Octo.NaN);
+	    yield return () => (Octo.PositiveInfinity, Octo.Zero, Octo.NaN);
+	    yield return () => (Octo.NegativeInfinity, Octo.NegativeZero, Octo.NaN);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_SubtractionTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, Octo.Zero);
+	    yield return () => (Octo.One, Octo.NegativeOne, Octo.Two);
+	    yield return () => (Octo.One, Octo.Two, Octo.NegativeOne);
+	    yield return () => (Octo.SmallestSubnormal, Octo.GreatestSubnormal, Values.CreateFloat<Octo>(0x8000_0FFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+	    yield return () => (Octo.PositiveInfinity, Octo.PositiveInfinity, Octo.NaN);
+	    yield return () => (Octo.NegativeInfinity, Octo.NegativeInfinity, Octo.NaN);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> op_UnaryNegationTestData()
+    {
+	    yield return () => (Octo.Zero, Octo.NegativeZero);
+	    yield return () => (Octo.One, Octo.NegativeOne);
+	    yield return () => (Octo.Two, Octo.NegativeTwo);
+	    yield return () => (Octo.Ten, Octo.NegativeTen);
+	    yield return () => (Octo.Hundred, Octo.NegativeHundred);
+	    yield return () => (Octo.Thousand, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_BitwiseAndTestData()
+    {
+	    yield return () => (Octo.Zero, Octo.One, Octo.Zero);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_BitwiseOrTestData()
+    {
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> op_BitwiseXorTestData()
+    {
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.Zero);
+	    yield return () => (Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> op_OnesComplementTestData()
+    {
+	    yield return () => (Octo.Zero, Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+	    yield return () => (Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+	    yield return () => (Values.CreateFloat<Octo>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Octo.Zero);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_EqualityTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, true); 
+	    yield return () => (Octo.Two, Octo.Two, true);
+	    yield return () => (Octo.NaN, Octo.NaN, false);
+	    yield return () => (Octo.GreatestSubnormal, Octo.GreatestSubnormal, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_InequalityTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, false);
+	    yield return () => (Octo.NaN, Octo.NaN, true);
+	    yield return () => (Octo.NegativeTwo, Octo.Two, true);
+	    yield return () => (Octo.SmallestSubnormal, Octo.GreatestSubnormal, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_GreaterThanOrEqualTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, true); 
+	    yield return () => (Octo.Two, Octo.Two, true);
+	    yield return () => (Octo.NaN, Octo.NaN, false);
+	    yield return () => (Octo.GreatestSubnormal, Octo.GreatestSubnormal, true);
+	    yield return () => (Octo.Two, Octo.One, true);
+	    yield return () => (Octo.Thousand, Octo.NegativeThousand, true);
+	    yield return () => (Octo.NegativeQuarter, Octo.NegativeHalf, true);
+	    yield return () => (Octo.Quarter, Octo.Half, false);
+	    yield return () => (Octo.Ten, Octo.Hundred, false);
+	    yield return () => (Octo.GreaterThanOneSmallest, Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_GreaterThanTestData()
+    {
+	    yield return () => (Octo.Two, Octo.One, true);
+	    yield return () => (Octo.Thousand, Octo.NegativeThousand, true);
+	    yield return () => (Octo.NegativeQuarter, Octo.NegativeHalf, true);
+	    yield return () => (Octo.Quarter, Octo.Half, false);
+	    yield return () => (Octo.Ten, Octo.Hundred, false);
+	    yield return () => (Octo.GreaterThanOneSmallest, Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_LessThanOrEqualTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, true); 
+	    yield return () => (Octo.Two, Octo.Two, true);
+	    yield return () => (Octo.NaN, Octo.NaN, false);
+	    yield return () => (Octo.GreatestSubnormal, Octo.GreatestSubnormal, true);
+	    yield return () => (Octo.Zero, Octo.One, true);
+	    yield return () => (Octo.Zero, Octo.Quarter, true);
+	    yield return () => (Octo.NegativeThousand, Octo.Thousand, true);
+	    yield return () => (Octo.NegativeOne, Octo.NegativeThree, false);
+	    yield return () => (Octo.Hundred, Octo.Two, false);
+	    yield return () => (Octo.LessThanOneLargest, Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, bool)>> op_LessThanTestData()
+    {
+	    yield return () => (Octo.Zero, Octo.One, true);
+	    yield return () => (Octo.Zero, Octo.Quarter, true);
+	    yield return () => (Octo.NegativeThousand, Octo.Thousand, true);
+	    yield return () => (Octo.NegativeOne, Octo.NegativeThree, false);
+	    yield return () => (Octo.Hundred, Octo.Two, false);
+	    yield return () => (Octo.LessThanOneLargest, Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> AbsTestData()
+    {
+	    yield return () => (Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One);
+	    yield return () => (Octo.NegativeHalf, Octo.Half);
+	    yield return () => (Octo.NegativeQuarter, Octo.Quarter);
+	    yield return () => (Octo.NegativeZero, Octo.Zero);
+	    yield return () => (Octo.NegativeInfinity, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsCanonicalTestData()
+    {
+	    yield return () => (Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsComplexNumberTestData()
+    {
+	    yield return () => (Octo.One, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsEvenIntegerTestData()
+    {
+	    yield return () => (Octo.Half, false);
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.Two, true);
+	    yield return () => (Octo.Three, false);
+	    yield return () => (Octo.Four, true);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NegativeTwo, true);
+	    yield return () => (Octo.NegativeThree, false);
+	    yield return () => (Octo.NegativeFour, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsFiniteTestData()
+    {
+	    yield return () => (Octo.One, true);
+	    yield return () => (Octo.NegativeOne, true);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.PositiveInfinity, false);
+	    yield return () => (Octo.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsImaginaryNumberTestData()
+    {
+	    yield return () => (Octo.One, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsInfinityTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.PositiveInfinity, true);
+	    yield return () => (Octo.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsIntegerTestData()
+    {
+	    yield return () => (Octo.Quarter, false);
+	    yield return () => (Octo.Half, false);
+	    yield return () => (Octo.Thousand, true);
+	    yield return () => (Octo.One, true);
+	    yield return () => (Octo.GreaterThanOneSmallest, false);
+	    yield return () => (Octo.SmallestSubnormal, false);
+	    yield return () => (Octo.NegativeOne, true);
+	    yield return () => (Octo.NegativeThousand, true);
+	    yield return () => (Octo.NegativeHalf, false);
+	    yield return () => (Octo.NegativeQuarter, false);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.PositiveInfinity, false);
+	    yield return () => (Octo.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsNaNTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NaN, true);
+	    yield return () => (Octo.PositiveInfinity, false);
+	    yield return () => (Octo.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsNegativeTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.GreatestSubnormal, false);
+	    yield return () => (Octo.PositiveInfinity, false);
+	    yield return () => (Octo.NaN, true);
+	    yield return () => (Octo.NegativeOne, true);
+	    yield return () => (Octo.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsNegativeInfinityTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.PositiveInfinity, false);
+	    yield return () => (Octo.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsNormalTestData()
+    {
+	    yield return () => (Octo.GreatestSubnormal, false);
+	    yield return () => (Octo.SmallestSubnormal, false);
+	    yield return () => (Octo.MaxValue, true);
+	    yield return () => (Octo.MinValue, true);
+	    yield return () => (Octo.One, true);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsOddIntegerTestData()
+    {
+	    yield return () => (Octo.Half, false);
+	    yield return () => (Octo.One, true);
+	    yield return () => (Octo.Two, false);
+	    yield return () => (Octo.Three, true);
+	    yield return () => (Octo.Four, false);
+	    yield return () => (Octo.NegativeOne, true);
+	    yield return () => (Octo.NegativeTwo, false);
+	    yield return () => (Octo.NegativeThree, true);
+	    yield return () => (Octo.NegativeFour, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsPositiveTestData()
+    {
+	    yield return () => (Octo.One, true);
+	    yield return () => (Octo.GreatestSubnormal, true);
+	    yield return () => (Octo.PositiveInfinity, true);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsPositiveInfinityTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.NegativeOne, false);
+	    yield return () => (Octo.NaN, false);
+	    yield return () => (Octo.PositiveInfinity, true);
+	    yield return () => (Octo.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsRealNumberTestData()
+    {
+	    yield return () => (Octo.GreatestSubnormal, true);
+	    yield return () => (Octo.MaxValue, true);
+	    yield return () => (Octo.NegativeThousand, true);
+	    yield return () => (Octo.PositiveInfinity, true);
+	    yield return () => (Octo.NegativeInfinity, true);
+	    yield return () => (Octo.NaN, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsSubnormalTestData()
+    {
+	    yield return () => (Octo.GreatestSubnormal, true);
+	    yield return () => (Octo.SmallestSubnormal, true);
+	    yield return () => (Octo.MaxValue, false);
+	    yield return () => (Octo.MinValue, false);
+	    yield return () => (Octo.One, false);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsZeroTestData()
+    {
+	    yield return () => (Octo.One, false);
+	    yield return () => (Octo.Epsilon, false);
+	    yield return () => (Octo.Zero, true);
+	    yield return () => (Octo.NegativeZero, true);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MaxMagnitudeTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.MinValue);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.One);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (-Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.One);
+	    yield return () => (Octo.NaN, Octo.One, Octo.NaN);
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.MaxValue);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MaxMagnitudeNumberTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.MinValue);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.One);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (-Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.One);
+	    yield return () => (Octo.NaN, Octo.One, Octo.One);
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.MaxValue);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MinMagnitudeTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.One);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.NegativeOne);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, -Octo.GreatestSubnormal);
+	    yield return () => (-Octo.Epsilon, Octo.One, -Octo.Epsilon);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.NegativeZero);
+	    yield return () => (Octo.NaN, Octo.One, Octo.NaN);
+	    yield return () => (Octo.Zero, Octo.One, Octo.Zero);
+	    yield return () => (Octo.Epsilon, Octo.One, Octo.Epsilon);
+	    yield return () => (Octo.GreatestSubnormal, Octo.One, Octo.GreatestSubnormal);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.One);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.One);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MinMagnitudeNumberTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.One);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.NegativeOne);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, -Octo.GreatestSubnormal);
+	    yield return () => (-Octo.Epsilon, Octo.One, -Octo.Epsilon);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.NegativeZero);
+	    yield return () => (Octo.NaN, Octo.One, Octo.One);
+	    yield return () => (Octo.Zero, Octo.One, Octo.Zero);
+	    yield return () => (Octo.Epsilon, Octo.One, Octo.Epsilon);
+	    yield return () => (Octo.GreatestSubnormal, Octo.One, Octo.GreatestSubnormal);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.One);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.One);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo, Octo)>> MultiplyAddEstimateTestData()
+    {
+		yield return () => (Octo.One, Octo.One, Octo.One, Octo.Two);
+		yield return () => (Octo.Ten, Octo.Ten, Octo.Zero, Octo.Hundred);
+		yield return () => (Octo.Five, Octo.Zero, Octo.Five, Octo.Five);
+		yield return () => (Octo.Half, Octo.Two, Octo.Two, Octo.Three);
+		yield return () => (Octo.Two, Octo.Four, Octo.Two, Octo.Ten);
+		yield return () => (Octo.Ten, Octo.Half, Octo.Five, Octo.Ten);
+		yield return () => (Values.CreateFloat<Octo>(0xBFFF_F400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), Octo.One, Octo.Two, Values.CreateFloat<Octo>(0x3FFF_E800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+    }
+
+    public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, Octo)>> ParseTestData()
+    {
+	    yield return () => ("10.0", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Ten);
+	    yield return () => ("3", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Three);
+	    yield return () => ("-3", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeThree);
+	    yield return () => ("2.0", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Two);
+	    yield return () => ("-2", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeTwo);
+	    yield return () => ("0", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Zero);
+	    yield return () => ("-0", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeZero);
+	    yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.MaxValue);
+	    yield return () => (NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Octo.PositiveInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NaNSymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NaN);
+	    
+	    yield return () => ("2.5E-1", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("0.250", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("$-0.25", NumberStyles.Currency, Helper.CustomInfo, Octo.NegativeQuarter);
+	    yield return () => ("1.000", NumberStyles.Float, CultureInfo.InvariantCulture, Octo.One);
+	    yield return () => ("1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.Thousand);
+	    yield return () => ("-1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, Octo)>> ParseSpanTestData()
+    {
+	    yield return () => ("10.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Ten);
+	    yield return () => ("3".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Three);
+	    yield return () => ("-3".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeThree);
+	    yield return () => ("2.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Two);
+	    yield return () => ("-2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeTwo);
+	    yield return () => ("0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Zero);
+	    yield return () => ("-0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeZero);
+	    yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.MaxValue);
+	    yield return () => (NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.PositiveInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NaNSymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NaN);
+	    
+	    yield return () => ("2.5E-1".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("0.250".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("$-0.25".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, Octo.NegativeQuarter);
+	    yield return () => ("1.000".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.One);
+	    yield return () => ("1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.Thousand);
+	    yield return () => ("-1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, Octo)>> ParseUtf8TestData()
+    {
+	    yield return () => ("10.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Ten);
+	    yield return () => ("3"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Three);
+	    yield return () => ("-3"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeThree);
+	    yield return () => ("2.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Two);
+	    yield return () => ("-2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeTwo);
+	    yield return () => ("0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Zero);
+	    yield return () => ("-0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeZero);
+	    yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.MaxValue);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.PositiveInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NegativeInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.NaNSymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.NaN);
+	    
+	    yield return () => ("2.5E-1"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("0.250"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.Quarter);
+	    yield return () => ("$-0.25"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, Octo.NegativeQuarter);
+	    yield return () => ("1.000"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Octo.One);
+	    yield return () => ("1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.Thousand);
+	    yield return () => ("-1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, Octo)>> TryParseTestData()
+    {
+		yield return () => ("10.0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Ten);
+		yield return () => ("3", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Three);
+		yield return () => ("-3", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeThree);
+		yield return () => ("2.0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Two);
+		yield return () => ("-2", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeTwo);
+		yield return () => ("0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Zero);
+		yield return () => ("-0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeZero);
+		yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.MaxValue);
+		yield return () => (NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.PositiveInfinity);
+		yield return () => (NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeInfinity);
+		yield return () => (NumberFormatInfo.CurrentInfo.NaNSymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NaN);
+		
+		yield return () => ("2.5E-1", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+		yield return () => ("0.250", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+		yield return () => ("$-0.25", NumberStyles.Currency, Helper.CustomInfo, true, Octo.NegativeQuarter);
+		yield return () => ("1.000", NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.One);
+		yield return () => ("1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.Thousand);
+		yield return () => ("-1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, Octo)>> TryParseSpanTestData()
+    {
+	    yield return () => ("10.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Ten);
+	    yield return () => ("3".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Three);
+	    yield return () => ("-3".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeThree);
+	    yield return () => ("2.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Two);
+	    yield return () => ("-2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeTwo);
+	    yield return () => ("0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Zero);
+	    yield return () => ("-0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeZero);
+	    yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.MaxValue);
+	    yield return () => (NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.PositiveInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeInfinity);
+	    yield return () => (NumberFormatInfo.CurrentInfo.NaNSymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NaN);
+	    
+	    yield return () => ("2.5E-1".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+	    yield return () => ("0.250".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+	    yield return () => ("$-0.25".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, true, Octo.NegativeQuarter);
+	    yield return () => ("1.000".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.One);
+	    yield return () => ("1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.Thousand);
+	    yield return () => ("-1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, Octo)>> TryParseUtf8TestData()
+    {
+	    yield return () => ("10.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Ten);
+	    yield return () => ("3"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Three);
+	    yield return () => ("-3"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeThree);
+	    yield return () => ("2.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Two);
+	    yield return () => ("-2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeTwo);
+	    yield return () => ("0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Zero);
+	    yield return () => ("-0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeZero);
+	    yield return () => ("1.61132571748576047361957211845200501064402387454966951747637125049607183E+78913"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.MaxValue);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.PositiveInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NegativeInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.CurrentInfo.NaNSymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.NaN);
+	    
+	    yield return () => ("2.5E-1"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+	    yield return () => ("0.250"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.Quarter);
+	    yield return () => ("$-0.25"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, true, Octo.NegativeQuarter);
+	    yield return () => ("1.000"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Octo.One);
+	    yield return () => ("1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.Thousand);
+	    yield return () => ("-1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Octo.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(Octo, string, IFormatProvider?, string)>> ToStringTestData()
+    {
+	    Octo value = Values.CreateFloat<Octo>(0x4000_C81C_D6E6_31F8, 0xA090_2DE0_0D1B_7175, 0x8E21_9652_BD3C_3611, 0x3404_EA4A_8C15_4C98);
+	    
+	    yield return () => (value, "F", CultureInfo.InvariantCulture, "12345.68");
+	    yield return () => (value, "F", Helper.CustomInfo, "12345.67890");
+	    yield return () => (value, "N3", CultureInfo.InvariantCulture, "12,345.679");
+	    yield return () => (value, "N", Helper.CustomInfo, "1_23_45.67890");
+	    yield return () => (value, "C", Helper.CustomInfo, "$12,345.68");
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo, Octo)>> ClampTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (-Octo.Epsilon, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.NaN, Octo.One, Octo.Thousand, Octo.NaN);
+	    yield return () => (Octo.Zero, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.Epsilon, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.GreatestSubnormal, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.Thousand, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.Thousand, Octo.Thousand);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.Thousand, Octo.Thousand);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> CopySignTestData()
+    {
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.NegativeOne, Octo.NegativeOne);
+	    yield return () => (Octo.Thousand, Octo.NegativeOne, Octo.NegativeThousand);
+	    yield return () => (Octo.NegativeHundred, Octo.NegativeOne, Octo.NegativeHundred);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MaxTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.One);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.One);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (-Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.One);
+	    yield return () => (Octo.NaN, Octo.One, Octo.NaN);
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.MaxValue);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MaxNumberTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.One);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.One);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, Octo.One);
+	    yield return () => (-Octo.Epsilon, Octo.One, Octo.One);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.One);
+	    yield return () => (Octo.NaN, Octo.One, Octo.One);
+	    yield return () => (Octo.Zero, Octo.One, Octo.One);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.MaxValue);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MinTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.MinValue);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.NegativeOne);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, -Octo.GreatestSubnormal);
+	    yield return () => (-Octo.Epsilon, Octo.One, -Octo.Epsilon);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.NegativeZero);
+	    yield return () => (Octo.NaN, Octo.One, Octo.NaN);
+	    yield return () => (Octo.Zero, Octo.One, Octo.Zero);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.One);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.One);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> MinNumberTestData()
+    {
+	    yield return () => (Octo.NegativeInfinity, Octo.One, Octo.NegativeInfinity);
+	    yield return () => (Octo.MinValue, Octo.One, Octo.MinValue);
+	    yield return () => (Octo.NegativeOne, Octo.One, Octo.NegativeOne);
+	    yield return () => (-Octo.GreatestSubnormal, Octo.One, -Octo.GreatestSubnormal);
+	    yield return () => (-Octo.Epsilon, Octo.One, -Octo.Epsilon);
+	    yield return () => (Octo.NegativeZero, Octo.One, Octo.NegativeZero);
+	    yield return () => (Octo.NaN, Octo.One, Octo.One);
+	    yield return () => (Octo.Zero, Octo.One, Octo.Zero);
+	    yield return () => (Octo.One, Octo.One, Octo.One);
+	    yield return () => (Octo.MaxValue, Octo.One, Octo.One);
+	    yield return () => (Octo.PositiveInfinity, Octo.One, Octo.One);
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> SignTestData()
+    {
+	    yield return () => (Octo.One, 1);
+	    yield return () => (Octo.NegativeOne, -1);
+	    yield return () => (Octo.Ten, 1);
+	    yield return () => (Octo.NegativeTen, -1);
+	    yield return () => (Octo.Zero, 0);
+	    yield return () => (Octo.NegativeZero, 0);
+    }
+
+    public static IEnumerable<Func<(Octo, bool)>> IsPow2TestData()
+    {
+	    yield return () => (Octo.Half, true);
+	    yield return () => (Octo.One, true);
+	    yield return () => (Octo.Two, true);
+	    yield return () => (Octo.Three, false);
+	    yield return () => (Octo.NegativeTwo, false);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> Log2TestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> CeilingTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> FloorTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int, MidpointRounding, Octo)>> RoundTestData()
+    {
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Octo.Four);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Octo.NegativeFour);
+		
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Octo.Four);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Octo.NegativeFour);
+		
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Octo.NegativeThree);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Octo.NegativeFour);
+		
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Octo.Four);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Octo.NegativeThree);
+		
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Octo.Three);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0x4000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Octo.Two);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_00CC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Octo.NegativeTwo);
+		yield return () => (Values.CreateFloat<Octo>(0xC000_0C00_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Octo.NegativeThree);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> TruncateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> GetExponentByteCountTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> GetExponentShortestBitLengthTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> GetSignificandBitLengthTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> GetSignificandByteCountTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, byte[], bool, int)>> TryWriteExponentBigEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, byte[], bool, int)>> TryWriteExponentLittleEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, byte[], bool, int)>> TryWriteSignificandBigEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, byte[], bool, int)>> TryWriteSignificandLittleEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> Atan2TestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> Atan2PiTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> BitDecrementTestData()
+    {
+	    yield return () => (Octo.One, Values.CreateFloat<Octo>(0x3FFFEFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+	    yield return () => (Octo.NegativeOne, Values.CreateFloat<Octo>(0xBFFFF00000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001));
+	    yield return () => (Octo.Zero, -Octo.Epsilon);
+	    yield return () => (Octo.NegativeInfinity, Octo.NegativeInfinity);
+	    yield return () => (Octo.PositiveInfinity, Octo.MaxValue);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> BitIncrementTestData()
+    {
+	    yield return () => (Octo.One, Values.CreateFloat<Octo>(0x3FFFF00000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001));
+	    yield return () => (Octo.NegativeOne, Values.CreateFloat<Octo>(0xBFFFEFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+	    yield return () => (Octo.NegativeZero, Octo.Epsilon);
+	    yield return () => (Octo.NegativeInfinity, Octo.MinValue);
+	    yield return () => (Octo.PositiveInfinity, Octo.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo, Octo)>> FusedMultiplyAddTestData()
+    {
+	    yield return () => (Octo.One, Octo.One, Octo.One, Octo.Two);
+	    yield return () => (Octo.Ten, Octo.Ten, Octo.Zero, Octo.Hundred);
+	    yield return () => (Octo.Five, Octo.Zero, Octo.Five, Octo.Five);
+	    yield return () => (Octo.Half, Octo.Two, Octo.Two, Octo.Three);
+	    yield return () => (Octo.Two, Octo.Four, Octo.Two, Octo.Ten);
+	    yield return () => (Octo.Ten, Octo.Half, Octo.Five, Octo.Ten);
+	    yield return () => (Values.CreateFloat<Octo>(0xBFFF_F400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), Octo.One, Octo.Two, Values.CreateFloat<Octo>(0x3FFF_E800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo)>> Ieee754RemainderTestData()
+    {
+	    yield return () => (Octo.Ten, Octo.Three, Octo.One);
+	    yield return () => (Octo.Ten, Octo.Two, Octo.Zero);
+	    yield return () => (Octo.NegativeTen, Octo.Three, Octo.NegativeOne);
+	    yield return () => (Octo.NegativeTen, Octo.Two, Octo.Zero);
+	    yield return () => (Octo.NegativeTen, Octo.Zero, Octo.NaN);
+    }
+
+    public static IEnumerable<Func<(Octo, int)>> ILogBTestData()
+    {
+	    yield return () => (Values.CreateFloat<Octo>(0x4000_9000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 10);
+	    yield return () => (Values.CreateFloat<Octo>(0x4003_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 64);
+	    yield return () => (Values.CreateFloat<Octo>(0x4007_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 128);
+	    yield return () => (Values.CreateFloat<Octo>(0xC003_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), 64);
+	    yield return () => (Octo.Zero, int.MinValue);
+    }
+
+    public static IEnumerable<Func<(Octo, Octo, Octo, Octo)>> LerpTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> ReciprocalEstimateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, Octo)>> ReciprocalSqrtEstimateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Octo, int, Octo)>> ScaleBTestData()
+    {
+	    yield return () => (Octo.Two, 3, Values.CreateFloat<Octo>(0x4000_3000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	    yield return () => (Octo.NegativeTwo, 3, Values.CreateFloat<Octo>(0xC000_3000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	    yield return () => (Octo.Zero, 6, Octo.Zero);
+	    yield return () => (Octo.Two, 300000, Octo.PositiveInfinity);
+	    yield return () => (Octo.Two, -300000, Octo.Zero);
+    }
+    public static IEnumerable<Func<(Octo, byte)>> ConvertToCheckedByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, byte)>> ConvertToSaturatingByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, byte)>> ConvertToTruncatingByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, UInt256)>> ConvertToCheckedUInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt256)>> ConvertToSaturatingUInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt256)>> ConvertToTruncatingUInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, UInt512)>> ConvertToCheckedUInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt512)>> ConvertToSaturatingUInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, UInt512)>> ConvertToTruncatingUInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, short)>> ConvertToCheckedInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, short)>> ConvertToSaturatingInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, short)>> ConvertToTruncatingInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, int)>> ConvertToCheckedInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, int)>> ConvertToSaturatingInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, int)>> ConvertToTruncatingInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, long)>> ConvertToCheckedInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, long)>> ConvertToSaturatingInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, long)>> ConvertToTruncatingInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, Int256)>> ConvertToCheckedInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int256)>> ConvertToSaturatingInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int256)>> ConvertToTruncatingInt256TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, Int512)>> ConvertToCheckedInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int512)>> ConvertToSaturatingInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Int512)>> ConvertToTruncatingInt512TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, Half)>> ConvertToCheckedHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, float)>> ConvertToCheckedSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, float)>> ConvertToSaturatingSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, float)>> ConvertToTruncatingSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, double)>> ConvertToCheckedDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Octo, Quad)>> ConvertToCheckedQuadTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Quad)>> ConvertToSaturatingQuadTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Octo, Quad)>> ConvertToTruncatingQuadTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(byte, Octo)>> ConvertFromCheckedByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(byte, Octo)>> ConvertFromSaturatingByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(byte, Octo)>> ConvertFromTruncatingByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(ushort, Octo)>> ConvertFromCheckedUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(ushort, Octo)>> ConvertFromSaturatingUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(ushort, Octo)>> ConvertFromTruncatingUInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(uint, Octo)>> ConvertFromCheckedUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(uint, Octo)>> ConvertFromSaturatingUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(uint, Octo)>> ConvertFromTruncatingUInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(ulong, Octo)>> ConvertFromCheckedUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(ulong, Octo)>> ConvertFromSaturatingUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(ulong, Octo)>> ConvertFromTruncatingUInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(UInt128, Octo)>> ConvertFromCheckedUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(UInt128, Octo)>> ConvertFromSaturatingUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(UInt128, Octo)>> ConvertFromTruncatingUInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(sbyte, Octo)>> ConvertFromCheckedSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(sbyte, Octo)>> ConvertFromSaturatingSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(sbyte, Octo)>> ConvertFromTruncatingSByteTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(short, Octo)>> ConvertFromCheckedInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(short, Octo)>> ConvertFromSaturatingInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(short, Octo)>> ConvertFromTruncatingInt16TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(int, Octo)>> ConvertFromCheckedInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(int, Octo)>> ConvertFromSaturatingInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(int, Octo)>> ConvertFromTruncatingInt32TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(long, Octo)>> ConvertFromCheckedInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(long, Octo)>> ConvertFromSaturatingInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(long, Octo)>> ConvertFromTruncatingInt64TestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Int128, Octo)>> ConvertFromCheckedInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Int128, Octo)>> ConvertFromSaturatingInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Int128, Octo)>> ConvertFromTruncatingInt128TestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(BigInteger, Octo)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(BigInteger, Octo)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(BigInteger, Octo)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(Half, Octo)>> ConvertFromCheckedHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Half, Octo)>> ConvertFromSaturatingHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(Half, Octo)>> ConvertFromTruncatingHalfTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(float, Octo)>> ConvertFromCheckedSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(float, Octo)>> ConvertFromSaturatingSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(float, Octo)>> ConvertFromTruncatingSingleTestData()
+	{
+		throw new NotImplementedException();
+	}
+
+	public static IEnumerable<Func<(double, Octo)>> ConvertFromCheckedDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(double, Octo)>> ConvertFromSaturatingDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+	
+	public static IEnumerable<Func<(double, Octo)>> ConvertFromTruncatingDoubleTestData()
+	{
+		throw new NotImplementedException();
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/QuadDataSources.cs b/src/MissingValues.Tests/Data/QuadDataSources.cs
new file mode 100644
index 0000000..152530f
--- /dev/null
+++ b/src/MissingValues.Tests/Data/QuadDataSources.cs
@@ -0,0 +1,2133 @@
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+using MissingValues.Tests.Data.Sources;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class QuadDataSources
+    : IMathOperatorsDataSource<Quad>,
+        IBitwiseOperatorsDataSource<Quad>,
+        IEqualityOperatorsDataSource<Quad>,
+        IComparisonOperatorsDataSource<Quad>,
+        INumberBaseDataSource<Quad>,
+        INumberDataSource<Quad>,
+        IBinaryNumberDataSource<Quad>,
+        IFloatingPointDataSource<Quad>,
+        IFloatingPointIeee754DataSource<Quad>
+{
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_AdditionTestData()
+    {
+		yield return () => (Quad.One, Quad.One, Quad.Two);
+		yield return () => (Quad.One, Quad.NegativeOne, Quad.Zero);
+		yield return () => (Quad.One, Quad.NegativeTwo, Quad.NegativeOne);
+		yield return () => (Quad.One, Quad.Four, Quad.Five);
+		yield return () => (Quad.Three, Quad.Two, Quad.Five);
+		yield return () => (Quad.SmallestSubnormal, Quad.GreatestSubnormal, Values.CreateFloat<Quad>(0x0001_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity);
+		yield return () => (Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity);
+		yield return () => (Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.PositiveInfinity);
+		yield return () => (Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NegativeInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> op_DecrementTestData()
+    {
+		yield return () => (Quad.NegativeOne, Quad.NegativeTwo);
+		yield return () => (Quad.Zero, Quad.NegativeOne);
+		yield return () => (Quad.One, Quad.Zero);
+		yield return () => (Quad.Two, Quad.One);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_DivisionTestData()
+    {
+		yield return () => (Quad.Ten, Quad.Ten, Quad.One);
+		yield return () => (Quad.Hundred, Quad.Ten, Quad.Ten);
+		yield return () => (Quad.NegativeThousand, Quad.Ten, Quad.NegativeHundred);
+		yield return () => (Quad.Zero, Quad.Zero, Quad.NaN);
+		yield return () => (Quad.One, Quad.Zero, Quad.PositiveInfinity);
+		yield return () => (Quad.NegativeOne, Quad.Zero, Quad.NegativeInfinity);
+		yield return () => (Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.NaN);
+		yield return () => (Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NaN);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> op_IncrementTestData()
+    {
+		yield return () => (Quad.NegativeTwo, Quad.NegativeOne);
+		yield return () => (Quad.NegativeOne, Quad.Zero);
+		yield return () => (Quad.Zero, Quad.One);
+		yield return () => (Quad.One, Quad.Two);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_ModulusTestData()
+    {
+	    yield return () => (Quad.Two, Quad.Four, Quad.Two);
+	    yield return () => (Quad.Half, Quad.Four, Quad.Half);
+	    yield return () => (Quad.Four, Quad.Half, Quad.Zero);
+	    yield return () => (Quad.NegativeFour, Quad.Half, Quad.NegativeZero);
+	    yield return () => (Quad.NegativeFour, Quad.Thousand, Quad.NegativeFour);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_MultiplyTestData()
+    {
+		yield return () => (Quad.One, Quad.One, Quad.One);
+		yield return () => (Quad.One, Quad.NegativeOne, Quad.NegativeOne);
+		yield return () => (Quad.Ten, Quad.Ten, Quad.Hundred);
+		yield return () => (Quad.NegativeHundred, Quad.Ten, Quad.NegativeThousand);
+		yield return () => (Quad.NegativeTen, Quad.Hundred, Quad.NegativeThousand);
+		yield return () => (Quad.Zero, Quad.NegativeThousand, Quad.NegativeZero);
+		yield return () => (Quad.Zero, Quad.PositiveInfinity, Quad.NaN);
+		yield return () => (Quad.NegativeZero, Quad.NegativeInfinity, Quad.NaN);
+		yield return () => (Quad.PositiveInfinity, Quad.Zero, Quad.NaN);
+		yield return () => (Quad.NegativeInfinity, Quad.NegativeZero, Quad.NaN);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_SubtractionTestData()
+    {
+		yield return () => (Quad.One, Quad.One, Quad.Zero);
+		yield return () => (Quad.One, Quad.NegativeOne, Quad.Two);
+		yield return () => (Quad.One, Quad.Two, Quad.NegativeOne);
+		yield return () => (Quad.SmallestSubnormal, Quad.GreatestSubnormal, Values.CreateFloat<Quad>(0x8000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+		yield return () => (Quad.PositiveInfinity, Quad.PositiveInfinity, Quad.NaN);
+		yield return () => (Quad.NegativeInfinity, Quad.NegativeInfinity, Quad.NaN);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> op_UnaryNegationTestData()
+    {
+	    yield return () => (Quad.Zero, Quad.NegativeZero);
+	    yield return () => (Quad.One, Quad.NegativeOne);
+	    yield return () => (Quad.Two, Quad.NegativeTwo);
+	    yield return () => (Quad.Ten, Quad.NegativeTen);
+	    yield return () => (Quad.Hundred, Quad.NegativeHundred);
+	    yield return () => (Quad.Thousand, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_BitwiseAndTestData()
+    {
+	    yield return () => (Quad.Zero, Quad.One, Quad.Zero);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001));
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_BitwiseOrTestData()
+    {
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> op_BitwiseXorTestData()
+    {
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.Zero);
+	    yield return () => (Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> op_OnesComplementTestData()
+    {
+	    yield return () => (Quad.Zero, Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+	    yield return () => (Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001), Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE));
+	    yield return () => (Values.CreateFloat<Quad>(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), Quad.Zero);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_EqualityTestData()
+    {
+		yield return () => (Quad.One, Quad.One, true); 
+		yield return () => (Quad.Two, Quad.Two, true);
+		yield return () => (Quad.NaN, Quad.NaN, false);
+		yield return () => (Quad.GreatestSubnormal, Quad.GreatestSubnormal, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_InequalityTestData()
+    {
+		yield return () => (Quad.One, Quad.One, false);
+		yield return () => (Quad.NaN, Quad.NaN, true);
+	    yield return () => (Quad.NegativeTwo, Quad.Two, true);
+		yield return () => (Quad.SmallestSubnormal, Quad.GreatestSubnormal, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_GreaterThanOrEqualTestData()
+    {
+	    yield return () => (Quad.One, Quad.One, true); 
+	    yield return () => (Quad.Two, Quad.Two, true);
+	    yield return () => (Quad.NaN, Quad.NaN, false);
+	    yield return () => (Quad.GreatestSubnormal, Quad.GreatestSubnormal, true);
+	    yield return () => (Quad.Two, Quad.One, true);
+	    yield return () => (Quad.Thousand, Quad.NegativeThousand, true);
+	    yield return () => (Quad.NegativeQuarter, Quad.NegativeHalf, true);
+	    yield return () => (Quad.Quarter, Quad.Half, false);
+	    yield return () => (Quad.Ten, Quad.Hundred, false);
+	    yield return () => (Quad.GreaterThanOneSmallest, Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_GreaterThanTestData()
+    {
+		yield return () => (Quad.Two, Quad.One, true);
+		yield return () => (Quad.Thousand, Quad.NegativeThousand, true);
+		yield return () => (Quad.NegativeQuarter, Quad.NegativeHalf, true);
+		yield return () => (Quad.Quarter, Quad.Half, false);
+		yield return () => (Quad.Ten, Quad.Hundred, false);
+		yield return () => (Quad.GreaterThanOneSmallest, Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_LessThanOrEqualTestData()
+    {
+	    yield return () => (Quad.One, Quad.One, true); 
+	    yield return () => (Quad.Two, Quad.Two, true);
+	    yield return () => (Quad.NaN, Quad.NaN, false);
+	    yield return () => (Quad.GreatestSubnormal, Quad.GreatestSubnormal, true);
+	    yield return () => (Quad.Zero, Quad.One, true);
+	    yield return () => (Quad.Zero, Quad.Quarter, true);
+	    yield return () => (Quad.NegativeThousand, Quad.Thousand, true);
+	    yield return () => (Quad.NegativeOne, Quad.NegativeThree, false);
+	    yield return () => (Quad.Hundred, Quad.Two, false);
+	    yield return () => (Quad.LessThanOneLargest, Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, bool)>> op_LessThanTestData()
+    {
+		yield return () => (Quad.Zero, Quad.One, true);
+		yield return () => (Quad.Zero, Quad.Quarter, true);
+		yield return () => (Quad.NegativeThousand, Quad.Thousand, true);
+		yield return () => (Quad.NegativeOne, Quad.NegativeThree, false);
+		yield return () => (Quad.Hundred, Quad.Two, false);
+		yield return () => (Quad.LessThanOneLargest, Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> AbsTestData()
+    {
+	    yield return () => (Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One);
+	    yield return () => (Quad.NegativeHalf, Quad.Half);
+	    yield return () => (Quad.NegativeQuarter, Quad.Quarter);
+	    yield return () => (Quad.NegativeZero, Quad.Zero);
+	    yield return () => (Quad.NegativeInfinity, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsCanonicalTestData()
+    {
+	    yield return () => (Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsComplexNumberTestData()
+    {
+	    yield return () => (Quad.One, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsEvenIntegerTestData()
+    {
+	    yield return () => (Quad.Half, false);
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.Two, true);
+	    yield return () => (Quad.Three, false);
+	    yield return () => (Quad.Four, true);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NegativeTwo, true);
+	    yield return () => (Quad.NegativeThree, false);
+	    yield return () => (Quad.NegativeFour, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsFiniteTestData()
+    {
+	    yield return () => (Quad.One, true);
+	    yield return () => (Quad.NegativeOne, true);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.PositiveInfinity, false);
+	    yield return () => (Quad.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsImaginaryNumberTestData()
+    {
+	    yield return () => (Quad.One, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsInfinityTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.PositiveInfinity, true);
+	    yield return () => (Quad.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsIntegerTestData()
+    {
+	    yield return () => (Quad.Quarter, false);
+	    yield return () => (Quad.Half, false);
+	    yield return () => (Quad.Thousand, true);
+	    yield return () => (Quad.One, true);
+	    yield return () => (Quad.GreaterThanOneSmallest, false);
+	    yield return () => (Quad.SmallestSubnormal, false);
+	    yield return () => (Quad.NegativeOne, true);
+	    yield return () => (Quad.NegativeThousand, true);
+	    yield return () => (Quad.NegativeHalf, false);
+	    yield return () => (Quad.NegativeQuarter, false);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.PositiveInfinity, false);
+	    yield return () => (Quad.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsNaNTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NaN, true);
+	    yield return () => (Quad.PositiveInfinity, false);
+	    yield return () => (Quad.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsNegativeTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.GreatestSubnormal, false);
+	    yield return () => (Quad.PositiveInfinity, false);
+	    yield return () => (Quad.NaN, true);
+	    yield return () => (Quad.NegativeOne, true);
+	    yield return () => (Quad.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsNegativeInfinityTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.PositiveInfinity, false);
+	    yield return () => (Quad.NegativeInfinity, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsNormalTestData()
+    {
+	    yield return () => (Quad.GreatestSubnormal, false);
+	    yield return () => (Quad.SmallestSubnormal, false);
+	    yield return () => (Quad.MaxValue, true);
+	    yield return () => (Quad.MinValue, true);
+	    yield return () => (Quad.One, true);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsOddIntegerTestData()
+    {
+	    yield return () => (Quad.Half, false);
+	    yield return () => (Quad.One, true);
+	    yield return () => (Quad.Two, false);
+	    yield return () => (Quad.Three, true);
+	    yield return () => (Quad.Four, false);
+	    yield return () => (Quad.NegativeOne, true);
+	    yield return () => (Quad.NegativeTwo, false);
+	    yield return () => (Quad.NegativeThree, true);
+	    yield return () => (Quad.NegativeFour, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsPositiveTestData()
+    {
+	    yield return () => (Quad.One, true);
+	    yield return () => (Quad.GreatestSubnormal, true);
+	    yield return () => (Quad.PositiveInfinity, true);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsPositiveInfinityTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.NegativeOne, false);
+	    yield return () => (Quad.NaN, false);
+	    yield return () => (Quad.PositiveInfinity, true);
+	    yield return () => (Quad.NegativeInfinity, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsRealNumberTestData()
+    {
+	    yield return () => (Quad.GreatestSubnormal, true);
+	    yield return () => (Quad.MaxValue, true);
+	    yield return () => (Quad.NegativeThousand, true);
+	    yield return () => (Quad.PositiveInfinity, true);
+	    yield return () => (Quad.NegativeInfinity, true);
+	    yield return () => (Quad.NaN, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsSubnormalTestData()
+    {
+	    yield return () => (Quad.GreatestSubnormal, true);
+	    yield return () => (Quad.SmallestSubnormal, true);
+	    yield return () => (Quad.MaxValue, false);
+	    yield return () => (Quad.MinValue, false);
+	    yield return () => (Quad.One, false);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsZeroTestData()
+    {
+	    yield return () => (Quad.One, false);
+	    yield return () => (Quad.Epsilon, false);
+	    yield return () => (Quad.Zero, true);
+	    yield return () => (Quad.NegativeZero, true);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MaxMagnitudeTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.MinValue);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.One);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (-Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.One);
+	    yield return () => (Quad.NaN, Quad.One, Quad.NaN);
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.MaxValue);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MaxMagnitudeNumberTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.MinValue);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.One);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (-Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.One);
+	    yield return () => (Quad.NaN, Quad.One, Quad.One);
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.MaxValue);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MinMagnitudeTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.One);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.NegativeOne);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, -Quad.GreatestSubnormal);
+	    yield return () => (-Quad.Epsilon, Quad.One, -Quad.Epsilon);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.NegativeZero);
+	    yield return () => (Quad.NaN, Quad.One, Quad.NaN);
+	    yield return () => (Quad.Zero, Quad.One, Quad.Zero);
+	    yield return () => (Quad.Epsilon, Quad.One, Quad.Epsilon);
+	    yield return () => (Quad.GreatestSubnormal, Quad.One, Quad.GreatestSubnormal);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.One);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.One);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MinMagnitudeNumberTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.One);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.NegativeOne);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, -Quad.GreatestSubnormal);
+	    yield return () => (-Quad.Epsilon, Quad.One, -Quad.Epsilon);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.NegativeZero);
+	    yield return () => (Quad.NaN, Quad.One, Quad.One);
+	    yield return () => (Quad.Zero, Quad.One, Quad.Zero);
+	    yield return () => (Quad.Epsilon, Quad.One, Quad.Epsilon);
+	    yield return () => (Quad.GreatestSubnormal, Quad.One, Quad.GreatestSubnormal);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.One);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.One);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad, Quad)>> MultiplyAddEstimateTestData()
+    {
+	    yield return () => (Quad.One, Quad.One, Quad.One, Quad.Two);
+	    yield return () => (Quad.Ten, Quad.Ten, Quad.Zero, Quad.Hundred);
+	    yield return () => (Quad.Five, Quad.Zero, Quad.Five, Quad.Five);
+	    yield return () => (Values.CreateFloat<Quad>(0xBFFF_4000_0000_0000, 0), Quad.One, Quad.Two, Values.CreateFloat<Quad>(0x3FFE_8000_0000_0000, 0));
+    }
+
+    public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, Quad)>> ParseTestData()
+    {
+        yield return () => ("2.0", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Two);
+		yield return () => ("-2", NumberStyles.Float, CultureInfo.InvariantCulture, -Quad.Two);
+		yield return () => ("1.189731495357231765085759326628007E+4932", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.MaxValue);
+		yield return () => ("0", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Zero);
+		yield return () => (NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Quad.PositiveInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NegativeInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NaNSymbol, NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NaN);
+		yield return () => ("256.4995", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+		yield return () => ("471581881", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+		yield return () => ("1.93561113", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+		yield return () => ("9715574.2", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+		yield return () => ("0.51438427732005011792", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+		yield return () => ("0.04201133209656899095", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+		yield return () => ("7.7E777", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+		yield return () => ("-7.7E-777", NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+		
+		yield return () => ("2.5E-1", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+		yield return () => ("0.250", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+		yield return () => ("$-0.25", NumberStyles.Currency, Helper.CustomInfo, Quad.NegativeQuarter);
+		yield return () => ("1.000", NumberStyles.Float, CultureInfo.InvariantCulture, Quad.One);
+		yield return () => ("1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.Thousand);
+		yield return () => ("-1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, Quad)>> ParseSpanTestData()
+    {
+	    yield return () => ("2.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Two);
+	    yield return () => ("-2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, -Quad.Two);
+	    yield return () => ("1.189731495357231765085759326628007E+4932".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.MaxValue);
+	    yield return () => ("0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Zero);
+	    yield return () => (NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.PositiveInfinity);
+	    yield return () => (NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NegativeInfinity);
+	    yield return () => (NumberFormatInfo.InvariantInfo.NaNSymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NaN);
+	    yield return () => ("256.4995".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+	    yield return () => ("471581881".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+	    yield return () => ("1.93561113".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+	    yield return () => ("9715574.2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+	    yield return () => ("0.51438427732005011792".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+	    yield return () => ("0.04201133209656899095".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+	    yield return () => ("7.7E777".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+	    yield return () => ("-7.7E-777".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+	    
+	    yield return () => ("2.5E-1".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+	    yield return () => ("0.250".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+	    yield return () => ("$-0.25".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, Quad.NegativeQuarter);
+	    yield return () => ("1.000".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.One);
+	    yield return () => ("1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.Thousand);
+	    yield return () => ("-1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, Quad)>> ParseUtf8TestData()
+    {
+        yield return () => ("2.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Two);
+	    yield return () => ("-2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, -Quad.Two);
+	    yield return () => ("1.189731495357231765085759326628007E+4932"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.MaxValue);
+	    yield return () => ("0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Zero);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.PositiveInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NegativeInfinity);
+	    yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.NaNSymbol), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.NaN);
+	    yield return () => ("256.4995"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+	    yield return () => ("471581881"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+	    yield return () => ("1.93561113"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+	    yield return () => ("9715574.2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+	    yield return () => ("0.51438427732005011792"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+	    yield return () => ("0.04201133209656899095"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+	    yield return () => ("7.7E777"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+	    yield return () => ("-7.7E-777"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+	    
+	    yield return () => ("2.5E-1"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+	    yield return () => ("0.250"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.Quarter);
+	    yield return () => ("$-0.25"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, Quad.NegativeQuarter);
+	    yield return () => ("1.000"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, Quad.One);
+	    yield return () => ("1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.Thousand);
+	    yield return () => ("-1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, Quad)>> TryParseTestData()
+    {
+		yield return () => ("2.0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Two);
+		yield return () => ("-2", NumberStyles.Float, CultureInfo.InvariantCulture, true, -Quad.Two);
+		yield return () => ("1.189731495357231765085759326628007E+4932", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.MaxValue);
+		yield return () => ("0", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Zero);
+		yield return () => (NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.PositiveInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NegativeInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NaNSymbol, NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NaN);
+		yield return () => ("256.4995", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+		yield return () => ("471581881", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+		yield return () => ("1.93561113", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+		yield return () => ("9715574.2", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+		yield return () => ("0.51438427732005011792", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+		yield return () => ("0.04201133209656899095", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+		yield return () => ("7.7E777", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+		yield return () => ("-7.7E-777", NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+		yield return () => ("1A", NumberStyles.Float, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("2.5E-1", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("0.250", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("$-0.25", NumberStyles.Currency, Helper.CustomInfo, true, Quad.NegativeQuarter);
+		yield return () => ("1.000", NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.One);
+		yield return () => ("1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.Thousand);
+		yield return () => ("-1,000.00", NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, Quad)>> TryParseSpanTestData()
+    {
+        yield return () => ("2.0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Two);
+		yield return () => ("-2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, -Quad.Two);
+		yield return () => ("1.189731495357231765085759326628007E+4932".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.MaxValue);
+		yield return () => ("0".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Zero);
+		yield return () => (NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.PositiveInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NegativeInfinity);
+		yield return () => (NumberFormatInfo.InvariantInfo.NaNSymbol.ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NaN);
+		yield return () => ("256.4995".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+		yield return () => ("471581881".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+		yield return () => ("1.93561113".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+		yield return () => ("9715574.2".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+		yield return () => ("0.51438427732005011792".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+		yield return () => ("0.04201133209656899095".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+		yield return () => ("7.7E777".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+		yield return () => ("-7.7E-777".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+		yield return () => ("1A".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("2.5E-1".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("0.250".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("$-0.25".ToCharArray(), NumberStyles.Currency, Helper.CustomInfo, true, Quad.NegativeQuarter);
+		yield return () => ("1.000".ToCharArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.One);
+		yield return () => ("1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.Thousand);
+		yield return () => ("-1,000.00".ToCharArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, Quad)>> TryParseUtf8TestData()
+    {
+        yield return () => ("2.0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Two);
+		yield return () => ("-2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, -Quad.Two);
+		yield return () => ("1.189731495357231765085759326628007E+4932"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.MaxValue);
+		yield return () => ("0"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Zero);
+		yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.PositiveInfinity);
+		yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NegativeInfinity);
+		yield return () => (Encoding.UTF8.GetBytes(NumberFormatInfo.InvariantInfo.NaNSymbol), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.NaN);
+		yield return () => ("256.4995"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4007_007F_DF3B_645A, 0x1CAC_0831_26E9_78D5));
+		yield return () => ("471581881"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x401B_C1BC_4B90_0000, 0x0000_0000_0000_0000));
+		yield return () => ("1.93561113"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFF_EF84_3605_1FA4, 0x8B0F_3D34_BECE_8762));
+		yield return () => ("9715574.2"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4016_287E_EC66_6666, 0x6666_6666_6666_6666));
+		yield return () => ("0.51438427732005011792"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFE_075D_6041_5519, 0x72D0_0AD3_7DB4_57E9));
+		yield return () => ("0.04201133209656899095"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x3FFA_5828_262D_512C, 0x8840_B3B3_D424_5947));
+		yield return () => ("7.7E777"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0x4A17_0F28_5D1D_4C84, 0xA11F_6899_101B_A9A4));
+		yield return () => ("-7.7E-777"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Values.CreateFloat<Quad>(0xB5EC_BFCE_3AF6_4E08, 0x42C8_5750_BEBD_A572));
+		yield return () => ("1A"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, false, default);
+		
+		yield return () => ("2.5E-1"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("0.250"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.Quarter);
+		yield return () => ("$-0.25"u8.ToArray(), NumberStyles.Currency, Helper.CustomInfo, true, Quad.NegativeQuarter);
+		yield return () => ("1.000"u8.ToArray(), NumberStyles.Float, CultureInfo.InvariantCulture, true, Quad.One);
+		yield return () => ("1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.Thousand);
+		yield return () => ("-1,000.00"u8.ToArray(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, true, Quad.NegativeThousand);
+    }
+
+    public static IEnumerable<Func<(Quad, string, IFormatProvider?, string)>> ToStringTestData()
+    {
+	    Quad value = Values.CreateFloat<Quad>(0x400C_81CD_6E63_1F8A, 0x0902_DE00_D1B7_1759);
+	    
+	    yield return () => (value, "F", CultureInfo.InvariantCulture, "12345.68");
+	    yield return () => (value, "F", Helper.CustomInfo, "12345.67890");
+	    yield return () => (value, "N3", CultureInfo.InvariantCulture, "12,345.679");
+	    yield return () => (value, "N", Helper.CustomInfo, "1_23_45.67890");
+	    yield return () => (value, "C", Helper.CustomInfo, "$12,345.68");
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad, Quad)>> ClampTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (-Quad.Epsilon, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.NaN, Quad.One, Quad.Thousand, Quad.NaN);
+	    yield return () => (Quad.Zero, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.Epsilon, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.GreatestSubnormal, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.Thousand, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.Thousand, Quad.Thousand);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.Thousand, Quad.Thousand);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> CopySignTestData()
+    {
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.NegativeOne, Quad.NegativeOne);
+	    yield return () => (Quad.Thousand, Quad.NegativeOne, Quad.NegativeThousand);
+	    yield return () => (Quad.NegativeHundred, Quad.NegativeOne, Quad.NegativeHundred);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MaxTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.One);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.One);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (-Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.One);
+	    yield return () => (Quad.NaN, Quad.One, Quad.NaN);
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.MaxValue);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MaxNumberTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.One);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.One);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, Quad.One);
+	    yield return () => (-Quad.Epsilon, Quad.One, Quad.One);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.One);
+	    yield return () => (Quad.NaN, Quad.One, Quad.One);
+	    yield return () => (Quad.Zero, Quad.One, Quad.One);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.MaxValue);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MinTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.MinValue);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.NegativeOne);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, -Quad.GreatestSubnormal);
+	    yield return () => (-Quad.Epsilon, Quad.One, -Quad.Epsilon);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.NegativeZero);
+	    yield return () => (Quad.NaN, Quad.One, Quad.NaN);
+	    yield return () => (Quad.Zero, Quad.One, Quad.Zero);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.One);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.One);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> MinNumberTestData()
+    {
+	    yield return () => (Quad.NegativeInfinity, Quad.One, Quad.NegativeInfinity);
+	    yield return () => (Quad.MinValue, Quad.One, Quad.MinValue);
+	    yield return () => (Quad.NegativeOne, Quad.One, Quad.NegativeOne);
+	    yield return () => (-Quad.GreatestSubnormal, Quad.One, -Quad.GreatestSubnormal);
+	    yield return () => (-Quad.Epsilon, Quad.One, -Quad.Epsilon);
+	    yield return () => (Quad.NegativeZero, Quad.One, Quad.NegativeZero);
+	    yield return () => (Quad.NaN, Quad.One, Quad.One);
+	    yield return () => (Quad.Zero, Quad.One, Quad.Zero);
+	    yield return () => (Quad.One, Quad.One, Quad.One);
+	    yield return () => (Quad.MaxValue, Quad.One, Quad.One);
+	    yield return () => (Quad.PositiveInfinity, Quad.One, Quad.One);
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> SignTestData()
+    {
+	    yield return () => (Quad.One, 1);
+	    yield return () => (Quad.NegativeOne, -1);
+	    yield return () => (Quad.Ten, 1);
+	    yield return () => (Quad.NegativeTen, -1);
+	    yield return () => (Quad.Zero, 0);
+	    yield return () => (Quad.NegativeZero, 0);
+    }
+
+    public static IEnumerable<Func<(Quad, bool)>> IsPow2TestData()
+    {
+	    yield return () => (Quad.Half, true);
+	    yield return () => (Quad.One, true);
+	    yield return () => (Quad.Two, true);
+	    yield return () => (Quad.Three, false);
+	    yield return () => (Quad.NegativeTwo, false);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> Log2TestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> CeilingTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> FloorTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int, MidpointRounding, Quad)>> RoundTestData()
+    {
+		yield return () => (Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Quad.Four);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.AwayFromZero, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.AwayFromZero, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.AwayFromZero, Quad.NegativeFour);
+		    
+		yield return () => (Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Quad.Four);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToEven, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToEven, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToEven, Quad.NegativeFour);
+		    
+		yield return () => (Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToNegativeInfinity, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToNegativeInfinity, Quad.NegativeThree);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToNegativeInfinity, Quad.NegativeFour);
+		    
+		yield return () => (Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Quad.Four);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToPositiveInfinity, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToPositiveInfinity, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToPositiveInfinity, Quad.NegativeThree);
+		    
+		yield return () => (Values.CreateFloat<Quad>(0x4000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Quad.Three);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0x4000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Quad.Two);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_0CCC_CCCC_CCCC, 0xCCCC_CCCC_CCCC_CCCD), 0, MidpointRounding.ToZero, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_4000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_6666_6666_6666, 0x6666_6666_6666_6666), 0, MidpointRounding.ToZero, Quad.NegativeTwo);
+		yield return () => (Values.CreateFloat<Quad>(0xC000_C000_0000_0000, 0x0000_0000_0000_0000), 0, MidpointRounding.ToZero, Quad.NegativeThree);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> TruncateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> GetExponentByteCountTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> GetExponentShortestBitLengthTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> GetSignificandBitLengthTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> GetSignificandByteCountTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, byte[], bool, int)>> TryWriteExponentBigEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, byte[], bool, int)>> TryWriteExponentLittleEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, byte[], bool, int)>> TryWriteSignificandBigEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, byte[], bool, int)>> TryWriteSignificandLittleEndianTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> Atan2TestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> Atan2PiTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> BitDecrementTestData()
+    {
+	    yield return () => (Quad.One, Values.CreateFloat<Quad>(0x3FFEFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+	    yield return () => (Quad.NegativeOne, Values.CreateFloat<Quad>(0xBFFF000000000000, 0x0000000000000001));
+	    yield return () => (Quad.Zero, -Quad.Epsilon);
+	    yield return () => (Quad.NegativeInfinity, Quad.NegativeInfinity);
+	    yield return () => (Quad.PositiveInfinity, Quad.MaxValue);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> BitIncrementTestData()
+    {
+	    yield return () => (Quad.One, Values.CreateFloat<Quad>(0x3FFF000000000000, 0x0000000000000001));
+	    yield return () => (Quad.NegativeOne, Values.CreateFloat<Quad>(0xBFFEFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+	    yield return () => (Quad.NegativeZero, Quad.Epsilon);
+	    yield return () => (Quad.NegativeInfinity, Quad.MinValue);
+	    yield return () => (Quad.PositiveInfinity, Quad.PositiveInfinity);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad, Quad)>> FusedMultiplyAddTestData()
+    {
+		yield return () => (Quad.One, Quad.One, Quad.One, Quad.Two);
+		yield return () => (Quad.Ten, Quad.Ten, Quad.Zero, Quad.Hundred);
+		yield return () => (Quad.Five, Quad.Zero, Quad.Five, Quad.Five);
+	    yield return () => (Values.CreateFloat<Quad>(0xBFFF_4000_0000_0000, 0), Quad.One, Quad.Two, Values.CreateFloat<Quad>(0x3FFE_8000_0000_0000, 0));
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad)>> Ieee754RemainderTestData()
+    {
+	    yield return () => (Quad.Ten, Quad.Three, Quad.One);
+	    yield return () => (Quad.Ten, Quad.Two, Quad.Zero);
+	    yield return () => (Quad.NegativeTen, Quad.Three, Quad.NegativeOne);
+	    yield return () => (Quad.NegativeTen, Quad.Two, Quad.NegativeZero);
+	    yield return () => (Quad.NegativeTen, Quad.Zero, Quad.NaN);
+    }
+
+    public static IEnumerable<Func<(Quad, int)>> ILogBTestData()
+    {
+	    yield return () => (Values.CreateFloat<Quad>(0x4009_0000_0000_0000, 0x0000_0000_0000_0000), 10);
+	    yield return () => (Values.CreateFloat<Quad>(0x403F_0000_0000_0000, 0x0000_0000_0000_0000), 64);
+	    yield return () => (Values.CreateFloat<Quad>(0xC03F_0000_0000_0000, 0x0000_0000_0000_0000), 64);
+	    yield return () => (Quad.Zero, int.MinValue);
+    }
+
+    public static IEnumerable<Func<(Quad, Quad, Quad, Quad)>> LerpTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> ReciprocalEstimateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, Quad)>> ReciprocalSqrtEstimateTestData()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static IEnumerable<Func<(Quad, int, Quad)>> ScaleBTestData()
+    {
+	    yield return () => (Quad.Two, 3, Values.CreateFloat<Quad>(0x4003_0000_0000_0000, 0x0000_0000_0000_0000));
+	    yield return () => (Quad.NegativeTwo, 3, Values.CreateFloat<Quad>(0xC003_0000_0000_0000, 0x0000_0000_0000_0000));
+	    yield return () => (Quad.Zero, 6, Quad.Zero);
+	    yield return () => (Quad.Two, 300000, Quad.PositiveInfinity);
+	    yield return () => (Quad.Two, -300000, Quad.Zero);
+    }
+    
+	public static IEnumerable<Func<(Quad, byte)>> ConvertToCheckedByteTestData()
+	{
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, byte)>> ConvertToSaturatingByteTestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.MaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, byte)>> ConvertToTruncatingByteTestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.MaxValue, byte.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.MaxValue, ushort.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.MaxValue, uint.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Quad.MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		yield return () => (Quad.NegativeOne, 0);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Quad.MaxValue, ulong.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		yield return () => (Quad.Half, UInt128.Zero);
+		yield return () => (Quad.One, UInt128.One);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		yield return () => (Quad.Half, UInt128.Zero);
+		yield return () => (Quad.One, UInt128.One);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Quad.TwoOver128, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		yield return () => (Quad.Half, UInt128.Zero);
+		yield return () => (Quad.One, UInt128.One);
+		yield return () => (Quad.ByteMaxValue, byte.MaxValue);
+		yield return () => (Quad.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (Quad.UInt32MaxValue, uint.MaxValue);
+		yield return () => (Quad.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (Quad.TwoOver128, UInt128.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, UInt256)>> ConvertToCheckedUInt256TestData()
+	{
+		yield return () => (Quad.Half, UInt256.Zero);
+		yield return () => (Quad.One, UInt256.One);
+		yield return () => (Quad.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt256.UInt128MaxValue + UInt256.One);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt256)>> ConvertToSaturatingUInt256TestData()
+	{
+		yield return () => (Quad.Half, UInt256.Zero);
+		yield return () => (Quad.One, UInt256.One);
+		yield return () => (Quad.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt256.UInt128MaxValue + UInt256.One);
+		yield return () => (Quad.TwoOver256, UInt256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt256)>> ConvertToTruncatingUInt256TestData()
+	{
+		yield return () => (Quad.Half, UInt256.Zero);
+		yield return () => (Quad.One, UInt256.One);
+		yield return () => (Quad.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt256.UInt128MaxValue + UInt256.One);
+		yield return () => (Quad.TwoOver256, UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, UInt512)>> ConvertToCheckedUInt512TestData()
+	{
+		yield return () => (Quad.Half, UInt512.Zero);
+		yield return () => (Quad.One, UInt512.One);
+		yield return () => (Quad.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt512.UInt128MaxValue + UInt512.One);
+		yield return () => (Quad.TwoOver256, UInt512.UInt256MaxValue + UInt512.One);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt512)>> ConvertToSaturatingUInt512TestData()
+	{
+		yield return () => (Quad.Half, UInt512.Zero);
+		yield return () => (Quad.One, UInt512.One);
+		yield return () => (Quad.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt512.UInt128MaxValue + UInt512.One);
+		yield return () => (Quad.TwoOver256, UInt512.UInt256MaxValue + UInt512.One);
+		yield return () => (Quad.TwoOver512, UInt512.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, UInt512)>> ConvertToTruncatingUInt512TestData()
+	{
+		yield return () => (Quad.Half, UInt512.Zero);
+		yield return () => (Quad.One, UInt512.One);
+		yield return () => (Quad.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (Quad.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (Quad.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (Quad.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (Quad.TwoOver128, UInt512.UInt128MaxValue + UInt512.One);
+		yield return () => (Quad.TwoOver256, UInt512.UInt256MaxValue + UInt512.One);
+		yield return () => (Quad.TwoOver512, UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		yield return () => (Quad.MinValue, sbyte.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.MaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		yield return () => (Quad.MinValue, sbyte.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.MaxValue, sbyte.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, short)>> ConvertToCheckedInt16TestData()
+	{
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, short)>> ConvertToSaturatingInt16TestData()
+	{
+		yield return () => (Quad.MinValue, short.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, short)>> ConvertToTruncatingInt16TestData()
+	{
+		yield return () => (Quad.MinValue, short.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.MaxValue, short.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, int)>> ConvertToCheckedInt32TestData()
+	{
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, int)>> ConvertToSaturatingInt32TestData()
+	{
+		yield return () => (Quad.MinValue, int.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, int)>> ConvertToTruncatingInt32TestData()
+	{
+		yield return () => (Quad.MinValue, int.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.MaxValue, int.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, long)>> ConvertToCheckedInt64TestData()
+	{
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, long)>> ConvertToSaturatingInt64TestData()
+	{
+		yield return () => (Quad.MinValue, long.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, long)>> ConvertToTruncatingInt64TestData()
+	{
+		yield return () => (Quad.MinValue, long.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, -1);
+		yield return () => (Quad.Half, 0);
+		yield return () => (Quad.One, 1);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.MaxValue, long.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, Int128.NegativeOne);
+		yield return () => (Quad.Half, Int128.Zero);
+		yield return () => (Quad.One, Int128.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		yield return () => (Quad.MinValue, Int128.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, Int128.NegativeOne);
+		yield return () => (Quad.Half, Int128.Zero);
+		yield return () => (Quad.One, Int128.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.TwoOver127, Int128.MaxValue);
+		yield return () => (Quad.MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		yield return () => (Quad.MinValue, Int128.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, Int128.NegativeOne);
+		yield return () => (Quad.Half, Int128.Zero);
+		yield return () => (Quad.One, Int128.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.TwoOver127, Int128.MaxValue);
+		yield return () => (Quad.MaxValue, Int128.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, Int256)>> ConvertToCheckedInt256TestData()
+	{
+		yield return () => (Quad.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int256.NegativeOne);
+		yield return () => (Quad.Half, Int256.Zero);
+		yield return () => (Quad.One, Int256.One);
+		yield return () => (Quad.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int256.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int256)>> ConvertToSaturatingInt256TestData()
+	{
+		yield return () => (Quad.MinValue, Int256.MinValue);
+		yield return () => (Quad.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int256.NegativeOne);
+		yield return () => (Quad.Half, Int256.Zero);
+		yield return () => (Quad.One, Int256.One);
+		yield return () => (Quad.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (Quad.TwoOver127, Int256.Int128MaxValue + Int256.One);
+		yield return () => (Quad.MaxValue, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int256)>> ConvertToTruncatingInt256TestData()
+	{
+		yield return () => (Quad.MinValue, Int256.MinValue);
+		yield return () => (Quad.Int64MinValue, Int256.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int256.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int256.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int256.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int256.NegativeOne);
+		yield return () => (Quad.Half, Int256.Zero);
+		yield return () => (Quad.One, Int256.One);
+		yield return () => (Quad.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (Quad.TwoOver127, Int256.Int128MaxValue + Int256.One);
+		yield return () => (Quad.MaxValue, Int256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, Int512)>> ConvertToCheckedInt512TestData()
+	{
+		yield return () => (Quad.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int512.NegativeOne);
+		yield return () => (Quad.Half, Int512.Zero);
+		yield return () => (Quad.One, Int512.One);
+		yield return () => (Quad.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int512.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int512)>> ConvertToSaturatingInt512TestData()
+	{
+		yield return () => (Quad.MinValue, Int512.MinValue);
+		yield return () => (Quad.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int512.NegativeOne);
+		yield return () => (Quad.Half, Int512.Zero);
+		yield return () => (Quad.One, Int512.One);
+		yield return () => (Quad.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (Quad.TwoOver127, Int512.Int128MaxValue + Int512.One);
+		yield return () => (Quad.TwoOver255, Int512.Int256MaxValue + Int512.One);
+		yield return () => (Quad.MaxValue, Int512.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, Int512)>> ConvertToTruncatingInt512TestData()
+	{
+		yield return () => (Quad.MinValue, Int512.MinValue);
+		yield return () => (Quad.Int64MinValue, Int512.Int64MinValue);
+		yield return () => (Quad.Int32MinValue, Int512.Int32MinValue);
+		yield return () => (Quad.Int16MinValue, Int512.Int16MinValue);
+		yield return () => (Quad.SByteMinValue, Int512.SByteMinValue);
+		yield return () => (Quad.NegativeOne, Int512.NegativeOne);
+		yield return () => (Quad.Half, Int512.Zero);
+		yield return () => (Quad.One, Int512.One);
+		yield return () => (Quad.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (Quad.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (Quad.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (Quad.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (Quad.TwoOver127, Int512.Int128MaxValue + Int512.One);
+		yield return () => (Quad.TwoOver255, Int512.Int256MaxValue + Int512.One);
+		yield return () => (Quad.MaxValue, Int512.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Quad, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		yield return () => (Quad.DoubleMinValue, (BigInteger)double.MinValue);
+		yield return () => (Quad.SingleMinValue, (BigInteger)float.MinValue);
+		yield return () => (Quad.HalfMinValue, (BigInteger)Half.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, BigInteger.MinusOne);
+		yield return () => (Quad.Half, BigInteger.Zero);
+		yield return () => (Quad.One, BigInteger.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.HalfMaxValue, (BigInteger)Half.MaxValue);
+		yield return () => (Quad.SingleMaxValue, (BigInteger)float.MaxValue);
+		yield return () => (Quad.DoubleMaxValue, (BigInteger)double.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		yield return () => (Quad.DoubleMinValue, (BigInteger)double.MinValue);
+		yield return () => (Quad.SingleMinValue, (BigInteger)float.MinValue);
+		yield return () => (Quad.HalfMinValue, (BigInteger)Half.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, BigInteger.MinusOne);
+		yield return () => (Quad.Half, BigInteger.Zero);
+		yield return () => (Quad.One, BigInteger.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.HalfMaxValue, (BigInteger)Half.MaxValue);
+		yield return () => (Quad.SingleMaxValue, (BigInteger)float.MaxValue);
+		yield return () => (Quad.DoubleMaxValue, (BigInteger)double.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		yield return () => (Quad.DoubleMinValue, (BigInteger)double.MinValue);
+		yield return () => (Quad.SingleMinValue, (BigInteger)float.MinValue);
+		yield return () => (Quad.HalfMinValue, (BigInteger)Half.MinValue);
+		yield return () => (Quad.Int64MinValue, long.MinValue);
+		yield return () => (Quad.Int32MinValue, int.MinValue);
+		yield return () => (Quad.Int16MinValue, short.MinValue);
+		yield return () => (Quad.SByteMinValue, sbyte.MinValue);
+		yield return () => (Quad.NegativeOne, BigInteger.MinusOne);
+		yield return () => (Quad.Half, BigInteger.Zero);
+		yield return () => (Quad.One, BigInteger.One);
+		yield return () => (Quad.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (Quad.Int16MaxValue, short.MaxValue);
+		yield return () => (Quad.Int32MaxValue, int.MaxValue);
+		yield return () => (Quad.Int64MaxValue, long.MaxValue);
+		yield return () => (Quad.HalfMaxValue, (BigInteger)Half.MaxValue);
+		yield return () => (Quad.SingleMaxValue, (BigInteger)float.MaxValue);
+		yield return () => (Quad.DoubleMaxValue, (BigInteger)double.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Quad, Half)>> ConvertToCheckedHalfTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Half.NegativeInfinity);
+		yield return () => (Quad.HalfMinValue, Half.MinValue);
+		yield return () => (Quad.NegativeOne, Half.NegativeOne);
+		yield return () => (Quad.Half, (Half)0.5f);
+		yield return () => (Quad.One, Half.One);
+		yield return () => (Quad.HalfMaxValue, Half.MaxValue);
+		yield return () => (Quad.PositiveInfinity, Half.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Half.NegativeInfinity);
+		yield return () => (Quad.HalfMinValue, Half.MinValue);
+		yield return () => (Quad.NegativeOne, Half.NegativeOne);
+		yield return () => (Quad.Half, (Half)0.5f);
+		yield return () => (Quad.One, Half.One);
+		yield return () => (Quad.HalfMaxValue, Half.MaxValue);
+		yield return () => (Quad.PositiveInfinity, Half.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Half.NegativeInfinity);
+		yield return () => (Quad.HalfMinValue, Half.MinValue);
+		yield return () => (Quad.NegativeOne, Half.NegativeOne);
+		yield return () => (Quad.Half, (Half)0.5f);
+		yield return () => (Quad.One, Half.One);
+		yield return () => (Quad.HalfMaxValue, Half.MaxValue);
+		yield return () => (Quad.PositiveInfinity, Half.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(Quad, float)>> ConvertToCheckedSingleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, float.NegativeInfinity);
+		yield return () => (Quad.SingleMinValue, float.MinValue);
+		yield return () => (Quad.NegativeOne, -1f);
+		yield return () => (Quad.Half, 0.5f);
+		yield return () => (Quad.One, 1f);
+		yield return () => (Quad.SingleMaxValue, float.MaxValue);
+		yield return () => (Quad.PositiveInfinity, float.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, float)>> ConvertToSaturatingSingleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, float.NegativeInfinity);
+		yield return () => (Quad.SingleMinValue, float.MinValue);
+		yield return () => (Quad.NegativeOne, -1f);
+		yield return () => (Quad.Half, 0.5f);
+		yield return () => (Quad.One, 1f);
+		yield return () => (Quad.SingleMaxValue, float.MaxValue);
+		yield return () => (Quad.PositiveInfinity, float.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, float)>> ConvertToTruncatingSingleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, float.NegativeInfinity);
+		yield return () => (Quad.SingleMinValue, float.MinValue);
+		yield return () => (Quad.NegativeOne, -1f);
+		yield return () => (Quad.Half, 0.5f);
+		yield return () => (Quad.One, 1f);
+		yield return () => (Quad.SingleMaxValue, float.MaxValue);
+		yield return () => (Quad.PositiveInfinity, float.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(Quad, double)>> ConvertToCheckedDoubleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, double.NegativeInfinity);
+		yield return () => (Quad.DoubleMinValue, double.MinValue);
+		yield return () => (Quad.NegativeOne, -1d);
+		yield return () => (Quad.Half, 0.5d);
+		yield return () => (Quad.One, 1d);
+		yield return () => (Quad.DoubleMaxValue, double.MaxValue);
+		yield return () => (Quad.PositiveInfinity, double.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, double.NegativeInfinity);
+		yield return () => (Quad.DoubleMinValue, double.MinValue);
+		yield return () => (Quad.NegativeOne, -1d);
+		yield return () => (Quad.Half, 0.5d);
+		yield return () => (Quad.One, 1d);
+		yield return () => (Quad.DoubleMaxValue, double.MaxValue);
+		yield return () => (Quad.PositiveInfinity, double.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, double.NegativeInfinity);
+		yield return () => (Quad.DoubleMinValue, double.MinValue);
+		yield return () => (Quad.NegativeOne, -1d);
+		yield return () => (Quad.Half, 0.5d);
+		yield return () => (Quad.One, 1d);
+		yield return () => (Quad.DoubleMaxValue, double.MaxValue);
+		yield return () => (Quad.PositiveInfinity, double.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(Quad, Octo)>> ConvertToCheckedOctoTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Octo.NegativeInfinity);
+		yield return () => (Quad.NegativeOne, Octo.NegativeOne);
+		yield return () => (Quad.Half, Octo.Half);
+		yield return () => (Quad.One, Octo.One);
+		yield return () => (Quad.PositiveInfinity, Octo.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, Octo)>> ConvertToSaturatingOctoTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Octo.NegativeInfinity);
+		yield return () => (Quad.NegativeOne, Octo.NegativeOne);
+		yield return () => (Quad.Half, Octo.Half);
+		yield return () => (Quad.One, Octo.One);
+		yield return () => (Quad.PositiveInfinity, Octo.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Quad, Octo)>> ConvertToTruncatingOctoTestData()
+	{
+		yield return () => (Quad.NegativeInfinity, Octo.NegativeInfinity);
+		yield return () => (Quad.NegativeOne, Octo.NegativeOne);
+		yield return () => (Quad.Half, Octo.Half);
+		yield return () => (Quad.One, Octo.One);
+		yield return () => (Quad.PositiveInfinity, Octo.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(byte, Quad)>> ConvertFromCheckedByteTestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Quad)>> ConvertFromSaturatingByteTestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, Quad)>> ConvertFromTruncatingByteTestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(ushort, Quad)>> ConvertFromCheckedUInt16TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Quad)>> ConvertFromSaturatingUInt16TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, Quad)>> ConvertFromTruncatingUInt16TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(uint, Quad)>> ConvertFromCheckedUInt32TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Quad)>> ConvertFromSaturatingUInt32TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, Quad)>> ConvertFromTruncatingUInt32TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+	}
+
+	public static IEnumerable<Func<(ulong, Quad)>> ConvertFromCheckedUInt64TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Quad)>> ConvertFromSaturatingUInt64TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, Quad)>> ConvertFromTruncatingUInt64TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt128, Quad)>> ConvertFromCheckedUInt128TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Quad.TwoOver128);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Quad)>> ConvertFromSaturatingUInt128TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Quad.TwoOver128);
+	}
+	
+	public static IEnumerable<Func<(UInt128, Quad)>> ConvertFromTruncatingUInt128TestData()
+	{
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (byte.MaxValue, Quad.ByteMaxValue);
+		yield return () => (ushort.MaxValue, Quad.UInt16MaxValue);
+		yield return () => (uint.MaxValue, Quad.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, Quad.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, Quad.TwoOver128);
+	}
+
+	public static IEnumerable<Func<(sbyte, Quad)>> ConvertFromCheckedSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Quad)>> ConvertFromSaturatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, Quad)>> ConvertFromTruncatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(short, Quad)>> ConvertFromCheckedInt16TestData()
+	{
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Quad)>> ConvertFromSaturatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, Quad)>> ConvertFromTruncatingInt16TestData()
+	{
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+	}
+
+	public static IEnumerable<Func<(int, Quad)>> ConvertFromCheckedInt32TestData()
+	{
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Quad)>> ConvertFromSaturatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, Quad)>> ConvertFromTruncatingInt32TestData()
+	{
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+	}
+
+	public static IEnumerable<Func<(long, Quad)>> ConvertFromCheckedInt64TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Quad)>> ConvertFromSaturatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, Quad)>> ConvertFromTruncatingInt64TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int128, Quad)>> ConvertFromCheckedInt128TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Quad.TwoOver127);
+	}
+	
+	public static IEnumerable<Func<(Int128, Quad)>> ConvertFromSaturatingInt128TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Quad.TwoOver127);
+	}
+	
+	public static IEnumerable<Func<(Int128, Quad)>> ConvertFromTruncatingInt128TestData()
+	{
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (-1, Quad.NegativeOne);
+		yield return () => (0, Quad.Zero);
+		yield return () => (1, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => (Int128.MaxValue, Quad.TwoOver127);
+	}
+	
+	public static IEnumerable<Func<(BigInteger, Quad)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		yield return () => ((BigInteger)double.MinValue, Quad.DoubleMinValue);
+		yield return () => ((BigInteger)float.MinValue, Quad.SingleMinValue);
+		yield return () => ((BigInteger)Half.MinValue, Quad.HalfMinValue);
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (BigInteger.MinusOne, Quad.NegativeOne);
+		yield return () => (BigInteger.Zero, Quad.Zero);
+		yield return () => (BigInteger.One, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => ((BigInteger)Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => ((BigInteger)float.MaxValue, Quad.SingleMaxValue);
+		yield return () => ((BigInteger)double.MaxValue, Quad.DoubleMaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Quad)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		yield return () => ((BigInteger)double.MinValue, Quad.DoubleMinValue);
+		yield return () => ((BigInteger)float.MinValue, Quad.SingleMinValue);
+		yield return () => ((BigInteger)Half.MinValue, Quad.HalfMinValue);
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (BigInteger.MinusOne, Quad.NegativeOne);
+		yield return () => (BigInteger.Zero, Quad.Zero);
+		yield return () => (BigInteger.One, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => ((BigInteger)Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => ((BigInteger)float.MaxValue, Quad.SingleMaxValue);
+		yield return () => ((BigInteger)double.MaxValue, Quad.DoubleMaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, Quad)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		yield return () => ((BigInteger)double.MinValue, Quad.DoubleMinValue);
+		yield return () => ((BigInteger)float.MinValue, Quad.SingleMinValue);
+		yield return () => ((BigInteger)Half.MinValue, Quad.HalfMinValue);
+		yield return () => (long.MinValue, Quad.Int64MinValue);
+		yield return () => (int.MinValue, Quad.Int32MinValue);
+		yield return () => (short.MinValue, Quad.Int16MinValue);
+		yield return () => (sbyte.MinValue, Quad.SByteMinValue);
+		yield return () => (BigInteger.MinusOne, Quad.NegativeOne);
+		yield return () => (BigInteger.Zero, Quad.Zero);
+		yield return () => (BigInteger.One, Quad.One);
+		yield return () => (sbyte.MaxValue, Quad.SByteMaxValue);
+		yield return () => (short.MaxValue, Quad.Int16MaxValue);
+		yield return () => (int.MaxValue, Quad.Int32MaxValue);
+		yield return () => (long.MaxValue, Quad.Int64MaxValue);
+		yield return () => ((BigInteger)Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => ((BigInteger)float.MaxValue, Quad.SingleMaxValue);
+		yield return () => ((BigInteger)double.MaxValue, Quad.DoubleMaxValue);
+	}
+
+	public static IEnumerable<Func<(Half, Quad)>> ConvertFromCheckedHalfTestData()
+	{
+		yield return () => (Half.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (Half.MinValue, Quad.HalfMinValue);
+		yield return () => (Half.NegativeOne, Quad.NegativeOne);
+		yield return () => (-(Half)0.5f, Quad.NegativeHalf);
+		yield return () => (Half.Zero, Quad.Zero);
+		yield return () => ((Half)0.5f, Quad.Half);
+		yield return () => (Half.One, Quad.One);
+		yield return () => (Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => (Half.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Half, Quad)>> ConvertFromSaturatingHalfTestData()
+	{
+		yield return () => (Half.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (Half.MinValue, Quad.HalfMinValue);
+		yield return () => (Half.NegativeOne, Quad.NegativeOne);
+		yield return () => (-(Half)0.5f, Quad.NegativeHalf);
+		yield return () => (Half.Zero, Quad.Zero);
+		yield return () => ((Half)0.5f, Quad.Half);
+		yield return () => (Half.One, Quad.One);
+		yield return () => (Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => (Half.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(Half, Quad)>> ConvertFromTruncatingHalfTestData()
+	{
+		yield return () => (Half.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (Half.MinValue, Quad.HalfMinValue);
+		yield return () => (Half.NegativeOne, Quad.NegativeOne);
+		yield return () => (-(Half)0.5f, Quad.NegativeHalf);
+		yield return () => (Half.Zero, Quad.Zero);
+		yield return () => ((Half)0.5f, Quad.Half);
+		yield return () => (Half.One, Quad.One);
+		yield return () => (Half.MaxValue, Quad.HalfMaxValue);
+		yield return () => (Half.PositiveInfinity, Quad.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(float, Quad)>> ConvertFromCheckedSingleTestData()
+	{
+		yield return () => (float.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (float.MinValue, Quad.SingleMinValue);
+		yield return () => (-1f, Quad.NegativeOne);
+		yield return () => (-0.5f, Quad.NegativeHalf);
+		yield return () => (0f, Quad.Zero);
+		yield return () => (0.5f, Quad.Half);
+		yield return () => (1f, Quad.One);
+		yield return () => (float.MaxValue, Quad.SingleMaxValue);
+		yield return () => (float.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(float, Quad)>> ConvertFromSaturatingSingleTestData()
+	{
+		yield return () => (float.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (float.MinValue, Quad.SingleMinValue);
+		yield return () => (-1f, Quad.NegativeOne);
+		yield return () => (-0.5f, Quad.NegativeHalf);
+		yield return () => (0f, Quad.Zero);
+		yield return () => (0.5f, Quad.Half);
+		yield return () => (1f, Quad.One);
+		yield return () => (float.MaxValue, Quad.SingleMaxValue);
+		yield return () => (float.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(float, Quad)>> ConvertFromTruncatingSingleTestData()
+	{
+		yield return () => (float.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (float.MinValue, Quad.SingleMinValue);
+		yield return () => (-1f, Quad.NegativeOne);
+		yield return () => (-0.5f, Quad.NegativeHalf);
+		yield return () => (0f, Quad.Zero);
+		yield return () => (0.5f, Quad.Half);
+		yield return () => (1f, Quad.One);
+		yield return () => (float.MaxValue, Quad.SingleMaxValue);
+		yield return () => (float.PositiveInfinity, Quad.PositiveInfinity);
+	}
+
+	public static IEnumerable<Func<(double, Quad)>> ConvertFromCheckedDoubleTestData()
+	{
+		yield return () => (double.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (double.MinValue, Quad.DoubleMinValue);
+		yield return () => (-1d, Quad.NegativeOne);
+		yield return () => (-0.5d, Quad.NegativeHalf);
+		yield return () => (0d, Quad.Zero);
+		yield return () => (0.5d, Quad.Half);
+		yield return () => (1d, Quad.One);
+		yield return () => (double.MaxValue, Quad.DoubleMaxValue);
+		yield return () => (double.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(double, Quad)>> ConvertFromSaturatingDoubleTestData()
+	{
+		yield return () => (double.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (double.MinValue, Quad.DoubleMinValue);
+		yield return () => (-1d, Quad.NegativeOne);
+		yield return () => (-0.5d, Quad.NegativeHalf);
+		yield return () => (0d, Quad.Zero);
+		yield return () => (0.5d, Quad.Half);
+		yield return () => (1d, Quad.One);
+		yield return () => (double.MaxValue, Quad.DoubleMaxValue);
+		yield return () => (double.PositiveInfinity, Quad.PositiveInfinity);
+	}
+	
+	public static IEnumerable<Func<(double, Quad)>> ConvertFromTruncatingDoubleTestData()
+	{
+		yield return () => (double.NegativeInfinity, Quad.NegativeInfinity);
+		yield return () => (double.MinValue, Quad.DoubleMinValue);
+		yield return () => (-1d, Quad.NegativeOne);
+		yield return () => (-0.5d, Quad.NegativeHalf);
+		yield return () => (0d, Quad.Zero);
+		yield return () => (0.5d, Quad.Half);
+		yield return () => (1d, Quad.One);
+		yield return () => (double.MaxValue, Quad.DoubleMaxValue);
+		yield return () => (double.PositiveInfinity, Quad.PositiveInfinity);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IBinaryIntegerDataSource.cs b/src/MissingValues.Tests/Data/Sources/IBinaryIntegerDataSource.cs
new file mode 100644
index 0000000..a44678a
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IBinaryIntegerDataSource.cs
@@ -0,0 +1,20 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IBinaryIntegerDataSource<T>
+    where T : IBinaryInteger<T>
+{
+    static abstract IEnumerable<Func<(T, T, Pair<T>)>> DivRemTestData();
+    static abstract IEnumerable<Func<(T, T)>> LeadingZeroCountTestData();
+    static abstract IEnumerable<Func<(T, T)>> PopCountTestData();
+    static abstract IEnumerable<Func<(byte[], bool, T)>> ReadBigEndianTestData();
+    static abstract IEnumerable<Func<(byte[], bool, T)>> ReadLittleEndianTestData();
+    static abstract IEnumerable<Func<(T, int, T)>> RotateLeftTestData();
+    static abstract IEnumerable<Func<(T, int, T)>> RotateRightTestData();
+    static abstract IEnumerable<Func<(T, T)>> TrailingZeroCountTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetByteCountTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetShortestBitLengthTestData();
+    static abstract IEnumerable<Func<(T, byte[], int)>> WriteBigEndianTestData();
+    static abstract IEnumerable<Func<(T, byte[], int)>> WriteLittleEndianTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IBinaryNumberDataSource.cs b/src/MissingValues.Tests/Data/Sources/IBinaryNumberDataSource.cs
new file mode 100644
index 0000000..329de97
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IBinaryNumberDataSource.cs
@@ -0,0 +1,10 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IBinaryNumberDataSource<T>
+    where T : IBinaryNumber<T>
+{
+    static abstract IEnumerable<Func<(T, bool)>> IsPow2TestData();
+    static abstract IEnumerable<Func<(T, T)>> Log2TestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IBitwiseOperatorsDataSource.cs b/src/MissingValues.Tests/Data/Sources/IBitwiseOperatorsDataSource.cs
new file mode 100644
index 0000000..36742e8
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IBitwiseOperatorsDataSource.cs
@@ -0,0 +1,12 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IBitwiseOperatorsDataSource<T>
+	where T : IBitwiseOperators<T, T, T>
+{
+	static abstract IEnumerable<Func<(T, T, T)>> op_BitwiseAndTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_BitwiseOrTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_BitwiseXorTestData();
+	static abstract IEnumerable<Func<(T, T)>> op_OnesComplementTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IComparisonOperatorsDataSource.cs b/src/MissingValues.Tests/Data/Sources/IComparisonOperatorsDataSource.cs
new file mode 100644
index 0000000..b9f9b99
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IComparisonOperatorsDataSource.cs
@@ -0,0 +1,12 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IComparisonOperatorsDataSource<T>
+	where T : IComparisonOperators<T, T, bool>
+{
+	static abstract IEnumerable<Func<(T, T, bool)>> op_GreaterThanOrEqualTestData();
+	static abstract IEnumerable<Func<(T, T, bool)>> op_GreaterThanTestData();
+	static abstract IEnumerable<Func<(T, T, bool)>> op_LessThanOrEqualTestData();
+	static abstract IEnumerable<Func<(T, T, bool)>> op_LessThanTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IEqualityOperatorsDataSource.cs b/src/MissingValues.Tests/Data/Sources/IEqualityOperatorsDataSource.cs
new file mode 100644
index 0000000..70b6f26
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IEqualityOperatorsDataSource.cs
@@ -0,0 +1,10 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IEqualityOperatorsDataSource<T>
+	where T : IEqualityOperators<T, T, bool>
+{
+	static abstract IEnumerable<Func<(T, T, bool)>> op_EqualityTestData();
+	static abstract IEnumerable<Func<(T, T, bool)>> op_InequalityTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IFloatingPointDataSource.cs b/src/MissingValues.Tests/Data/Sources/IFloatingPointDataSource.cs
new file mode 100644
index 0000000..06ec3b1
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IFloatingPointDataSource.cs
@@ -0,0 +1,20 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IFloatingPointDataSource<T> 
+    where T : IFloatingPoint<T>
+{
+    static abstract IEnumerable<Func<(T, T)>> CeilingTestData();
+    static abstract IEnumerable<Func<(T, T)>> FloorTestData();
+    static abstract IEnumerable<Func<(T, int, MidpointRounding, T)>> RoundTestData();
+    static abstract IEnumerable<Func<(T, T)>> TruncateTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetExponentByteCountTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetExponentShortestBitLengthTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetSignificandBitLengthTestData();
+    static abstract IEnumerable<Func<(T, int)>> GetSignificandByteCountTestData();
+    static abstract IEnumerable<Func<(T, byte[], bool, int)>> TryWriteExponentBigEndianTestData();
+    static abstract IEnumerable<Func<(T, byte[], bool, int)>> TryWriteExponentLittleEndianTestData();
+    static abstract IEnumerable<Func<(T, byte[], bool, int)>> TryWriteSignificandBigEndianTestData();
+    static abstract IEnumerable<Func<(T, byte[], bool, int)>> TryWriteSignificandLittleEndianTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IFloatingPointIeee754DataSource.cs b/src/MissingValues.Tests/Data/Sources/IFloatingPointIeee754DataSource.cs
new file mode 100644
index 0000000..d6abd22
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IFloatingPointIeee754DataSource.cs
@@ -0,0 +1,19 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IFloatingPointIeee754DataSource<T> 
+    where T : IFloatingPointIeee754<T>
+{
+    static abstract IEnumerable<Func<(T, T, T)>> Atan2TestData();
+    static abstract IEnumerable<Func<(T, T, T)>> Atan2PiTestData();
+    static abstract IEnumerable<Func<(T, T)>> BitDecrementTestData();
+    static abstract IEnumerable<Func<(T, T)>> BitIncrementTestData();
+    static abstract IEnumerable<Func<(T, T, T, T)>> FusedMultiplyAddTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> Ieee754RemainderTestData();
+    static abstract IEnumerable<Func<(T, int)>> ILogBTestData();
+    static abstract IEnumerable<Func<(T, T, T, T)>> LerpTestData();
+    static abstract IEnumerable<Func<(T, T)>> ReciprocalEstimateTestData();
+    static abstract IEnumerable<Func<(T, T)>> ReciprocalSqrtEstimateTestData();
+    static abstract IEnumerable<Func<(T, int, T)>> ScaleBTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IMathOperators.cs b/src/MissingValues.Tests/Data/Sources/IMathOperators.cs
new file mode 100644
index 0000000..f29ff9b
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IMathOperators.cs
@@ -0,0 +1,49 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IMathOperatorsDataSource<T>
+	where T 
+	: 
+	IAdditionOperators<T, T, T>,
+	IIncrementOperators<T>,
+	ISubtractionOperators<T, T, T>,
+	IDecrementOperators<T>,
+	IMultiplyOperators<T, T, T>,
+	IDivisionOperators<T, T, T>,
+	IModulusOperators<T, T, T>
+{
+	static abstract IEnumerable<Func<(T, T, T)>> op_AdditionTestData();
+
+	static virtual IEnumerable<Func<(T, T, T, bool)>> op_CheckedAdditionTestData()
+	{
+		throw new NotSupportedException();
+	}
+	static virtual IEnumerable<Func<(T, T, bool)>> op_CheckedDecrementTestData()
+	{
+		throw new NotSupportedException();
+	}
+	static virtual IEnumerable<Func<(T, T, bool)>> op_CheckedIncrementTestData()
+	{
+		throw new NotSupportedException();
+	}
+	static virtual IEnumerable<Func<(T, T, T, bool)>> op_CheckedMultiplyTestData()
+	{
+		throw new NotSupportedException();
+	}
+	static virtual IEnumerable<Func<(T, T, T, bool)>> op_CheckedSubtractionTestData()
+	{
+		throw new NotSupportedException();
+	}
+	static abstract IEnumerable<Func<(T, T)>> op_DecrementTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_DivisionTestData();
+	static abstract IEnumerable<Func<(T, T)>> op_IncrementTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_ModulusTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_MultiplyTestData();
+	static abstract IEnumerable<Func<(T, T, T)>> op_SubtractionTestData();
+	static abstract IEnumerable<Func<(T, T)>> op_UnaryNegationTestData();
+	static virtual IEnumerable<Func<(T, T, bool)>> op_CheckedUnaryNegationTestData()
+	{
+		throw new NotSupportedException();
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/INumberBaseDataSource.cs b/src/MissingValues.Tests/Data/Sources/INumberBaseDataSource.cs
new file mode 100644
index 0000000..38172ac
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/INumberBaseDataSource.cs
@@ -0,0 +1,39 @@
+using System.Globalization;
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface INumberBaseDataSource<T>
+    where T : INumberBase<T>
+{
+    static abstract IEnumerable<Func<(T, T)>> AbsTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsCanonicalTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsComplexNumberTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsEvenIntegerTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsFiniteTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsImaginaryNumberTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsInfinityTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsIntegerTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsNaNTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsNegativeTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsNegativeInfinityTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsNormalTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsOddIntegerTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsPositiveTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsPositiveInfinityTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsRealNumberTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsSubnormalTestData();
+    static abstract IEnumerable<Func<(T, bool)>> IsZeroTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MaxMagnitudeTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MaxMagnitudeNumberTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MinMagnitudeTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MinMagnitudeNumberTestData();
+    static abstract IEnumerable<Func<(T, T, T, T)>> MultiplyAddEstimateTestData();
+    static abstract IEnumerable<Func<(string, NumberStyles, IFormatProvider?, T)>> ParseTestData();
+    static abstract IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, T)>> ParseSpanTestData();
+    static abstract IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, T)>> ParseUtf8TestData();
+    static abstract IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, T)>> TryParseTestData();
+    static abstract IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, T)>> TryParseSpanTestData();
+    static abstract IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, T)>> TryParseUtf8TestData();
+    static abstract IEnumerable<Func<(T, string, IFormatProvider?, string)>> ToStringTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/INumberDataSource.cs b/src/MissingValues.Tests/Data/Sources/INumberDataSource.cs
new file mode 100644
index 0000000..f06a3e5
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/INumberDataSource.cs
@@ -0,0 +1,15 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface INumberDataSource<T>
+    where T : INumber<T>
+{
+    static abstract IEnumerable<Func<(T, T, T, T)>> ClampTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> CopySignTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MaxTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MaxNumberTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MinTestData();
+    static abstract IEnumerable<Func<(T, T, T)>> MinNumberTestData();
+    static abstract IEnumerable<Func<(T, int)>> SignTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/Sources/IShiftOperatorsDataSource.cs b/src/MissingValues.Tests/Data/Sources/IShiftOperatorsDataSource.cs
new file mode 100644
index 0000000..6f40c21
--- /dev/null
+++ b/src/MissingValues.Tests/Data/Sources/IShiftOperatorsDataSource.cs
@@ -0,0 +1,11 @@
+using System.Numerics;
+
+namespace MissingValues.Tests.Data.Sources;
+
+public interface IShiftOperatorsDataSource<T>
+	where T : IShiftOperators<T, int, T>
+{
+	static abstract IEnumerable<Func<(T, int, T)>> op_ShiftLeftTestData();
+	static abstract IEnumerable<Func<(T, int, T)>> op_ShiftRightTestData();
+	static abstract IEnumerable<Func<(T, int, T)>> op_UnsignedShiftRightTestData();
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Data/UInt256DataSources.cs b/src/MissingValues.Tests/Data/UInt256DataSources.cs
new file mode 100644
index 0000000..d4f487c
--- /dev/null
+++ b/src/MissingValues.Tests/Data/UInt256DataSources.cs
@@ -0,0 +1,1899 @@
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using MissingValues.Tests.Data.Sources;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class UInt256DataSources
+	: IMathOperatorsDataSource<UInt256>,
+	IShiftOperatorsDataSource<UInt256>,
+	IBitwiseOperatorsDataSource<UInt256>,
+	IEqualityOperatorsDataSource<UInt256>, 
+	IComparisonOperatorsDataSource<UInt256>,
+	INumberBaseDataSource<UInt256>,
+	INumberDataSource<UInt256>,
+	IBinaryNumberDataSource<UInt256>,
+	IBinaryIntegerDataSource<UInt256>
+{
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_AdditionTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, UInt256.One, UInt256.One);
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 2), new UInt256(0, 0, 0, 3));
+		yield return () => (new UInt256(0, 0, 1, ulong.MaxValue), new UInt256(0, 0, 1, 1), new UInt256(0, 0, 3, 0));
+		yield return () => (new UInt256(0, 1, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 1, 1, 1), new UInt256(0, 3, 1, 0));
+		yield return () => (new UInt256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, 1, 1, 1), new UInt256(3, 1, 1, 0));
+		yield return () => (UInt256.MaxValue, UInt256.One, UInt256.Zero);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256, bool)>> op_CheckedAdditionTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero, false);
+		yield return () => (UInt256.Zero, UInt256.One, UInt256.One, false);
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 2), new UInt256(0, 0, 0, 3), false);
+		yield return () => (new UInt256(0, 0, 1, ulong.MaxValue), new UInt256(0, 0, 1, 1), new UInt256(0, 0, 3, 0), false);
+		yield return () => (new UInt256(0, 1, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 1, 1, 1), new UInt256(0, 3, 1, 0), false);
+		yield return () => (new UInt256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, 1, 1, 1), new UInt256(3, 1, 1, 0), false);
+		yield return () => (UInt256.MaxValue, UInt256.One, UInt256.Zero, true);
+		yield return () => (new UInt256(ulong.MaxValue, 0, 0, 0), new UInt256(1, 0, 0, 0), UInt256.Zero, true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256)>> op_IncrementTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.One);
+		yield return () => (new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, 0, 0, 0));
+		yield return () => (UInt256.MaxValue, UInt256.Zero);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_CheckedIncrementTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.One, false);
+		yield return () => (new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, 0, 0, 0), false);
+		yield return () => (UInt256.MaxValue, UInt256.Zero, true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_SubtractionTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.Zero, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), UInt256.Zero);
+		yield return () => (new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 3), new UInt256(0, 0, 0, 2));
+		yield return () => (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, ulong.MaxValue));
+		yield return () => (new UInt256(1, 0, 0, 0), UInt256.One, new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (UInt256.Zero, UInt256.One, UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> op_UnaryNegationTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_CheckedUnaryNegationTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256, bool)>> op_CheckedSubtractionTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero, false);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.Zero, new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), UInt256.Zero, false);
+		yield return () => (new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 3), new UInt256(0, 0, 0, 2), false);
+		yield return () => (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, ulong.MaxValue), false);
+		yield return () => (new UInt256(1, 0, 0, 0), UInt256.One, new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), false);
+		yield return () => (UInt256.Zero, UInt256.One, UInt256.MaxValue, true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256)>> op_DecrementTestData()
+	{
+		yield return () => (UInt256.One, UInt256.Zero);
+		yield return () => (new UInt256(1, 0, 0, 0), new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (UInt256.Zero, UInt256.MaxValue);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_CheckedDecrementTestData()
+	{
+		yield return () => (UInt256.One, UInt256.Zero, false);
+		yield return () => (new UInt256(1, 0, 0, 0), new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), false);
+		yield return () => (UInt256.Zero, UInt256.MaxValue, true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_MultiplyTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, new UInt256(1, 2, 3, 4), UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.One, new UInt256(1, 2, 3, 4));
+		yield return () => (UInt256.One, new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0, 3), new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 15));
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, ulong.MaxValue - 1, 1));
+		yield return () => (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 10, 0));
+		yield return () => (new UInt256(1, 1, 1, 1), new UInt256(2, 2, 2, 2), new UInt256(8, 6, 4, 2));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256, bool)>> op_CheckedMultiplyTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero, false);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.Zero, UInt256.Zero, false);
+		yield return () => (UInt256.Zero, new UInt256(1, 2, 3, 4), UInt256.Zero, false);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.One, new UInt256(1, 2, 3, 4), false);
+		yield return () => (UInt256.One, new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(0, 0, 0, 3), new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 15), false);
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, ulong.MaxValue - 1, 1), false);
+		yield return () => (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 10, 0), false);
+		yield return () => (new UInt256(1, 1, 1, 1), new UInt256(2, 2, 2, 2), new UInt256(8, 6, 4, 2), true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_DivisionTestData()
+	{
+		yield return () => (UInt256.One, UInt256.Zero, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.One, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), UInt256.One);
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(1, 0, 0, 0), UInt256.Zero);
+		yield return () => (new UInt256(0, 0, 0, 1000), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 100));
+		yield return () => (new UInt256(0x0, 0x1, 0x0, 0x0), new UInt256(0x0, 0x0, 0x0, 0x2), new UInt256(0x0, 0x0, 0x8000_0000_0000_0000, 0x0));
+		yield return () => (new UInt256(0x0, 0x1, 0x2, 0x3), new UInt256(0x0, 0x0, 0x0, 0x10), new UInt256(0x0, 0x0, 0x1000_0000_0000_0000, 0x2000_0000_0000_0000));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_ModulusTestData()
+	{
+		yield return () => (UInt256.One, UInt256.Zero, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.One, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), UInt256.Zero);
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(1, 0, 0, 0), new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 1000), new UInt256(0, 0, 0, 10), UInt256.Zero);
+		yield return () => (new UInt256(0, 0, 0, 1234), new UInt256(0, 0, 0, 1000), new UInt256(0, 0, 0, 234));
+		yield return () => (new UInt256(0x2, 0x0, 0x0, 0x0), new UInt256(0x0, 0x1, 0x0, 0x0), UInt256.Zero);
+		yield return () => (new UInt256(0x0, 0x1, 0x2, 0x3), new UInt256(0x0, 0x0, 0x0, 0x10), new UInt256(0x0, 0x0, 0x0, 0x3));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256)>> op_OnesComplementTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.MaxValue);
+		yield return () => (UInt256.MaxValue, UInt256.Zero);
+		yield return () => (new UInt256(0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555), new UInt256(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA));
+		yield return () => (new UInt256(0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new UInt256(~0x0123456789ABCDEFU, ~0xFEDCBA9876543210U, ~0x0F0F0F0F0F0F0F0FU, ~0xF0F0F0F0F0F0F0F0U));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_BitwiseAndTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, UInt256.MaxValue, UInt256.Zero);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.MaxValue, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0xFFFFFFFF00000000, 0xAAAAAAAA55555555, 0x123456789ABCDEF0, 0x0F0F0F0F0F0F0F0F), new UInt256(0x00000000FFFFFFFF, 0x55555555AAAAAAAA, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new UInt256(0x0000000000000000, 0x0000000000000000, 0x020406080A0C0E00, 0x0000000000000000));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_BitwiseOrTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (new UInt256(0x00000000FFFFFFFF, 0xAAAAAAAA00000000, 0x00000000AAAAAAAA, 0x1234567890ABCDEF), new UInt256(0xFFFFFFFF00000000, 0x0000000055555555, 0x5555555500000000, 0xFEDCBA9876543210), new UInt256(0xFFFFFFFFFFFFFFFF, 0xAAAAAAAA55555555, 0x55555555AAAAAAAA, 0xFEFCFEF8F6FFFFFF));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> op_BitwiseXorTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), UInt256.Zero);
+		yield return () => (new UInt256(0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x1234567890ABCDEF, 0xFEDCBA9876543210), UInt256.MaxValue, new UInt256(ulong.MaxValue, 0x0, 0xEDCBA9876F543210, 0x0123456789ABCDEF));
+		yield return () => (new UInt256(0x1234567890ABCDEF, 0xAAAAAAAA00000000, 0x00000000AAAAAAAA, 0xFFFFFFFFFFFFFFFF), new UInt256(0xFFFFFFFFFFFFFFFF, 0x00000000AAAAAAAA, 0xAAAAAAAA00000000, 0x0000000000000000), new UInt256(0xEDCBA9876F543210, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xFFFFFFFFFFFFFFFF));
+	}
+	public static IEnumerable<Func<(UInt256, int, UInt256)>> op_ShiftLeftTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), 0, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0, 1), 1, new UInt256(0, 0, 0, 2));
+		yield return () => (new UInt256(0, 0, 0, 1), 63, new UInt256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt256(0, 0, 0, 1), 64, new UInt256(0, 0, 1, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), 65, new UInt256(0, 0, 2, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), 128, new UInt256(0, 1, 0, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), 192, new UInt256(1, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), 255, new UInt256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), 256, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 1), 260, new UInt256(0, 0, 0, 16));
+	}
+	public static IEnumerable<Func<(UInt256, int, UInt256)>> op_ShiftRightTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), 0, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0, 16), 1, new UInt256(0, 0, 0, 8));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 63, new UInt256(1, 0, 0, 0));
+		yield return () => (new UInt256(1, 2, 3, 4), 64, new UInt256(0, 1, 2, 3));
+		yield return () => (new UInt256(1, 0, 0, 0), 65, new UInt256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => (new UInt256(1, 0, 0, 0), 128, new UInt256(0, 0, 1, 0));
+		yield return () => (new UInt256(1, 0, 0, 0), 192, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 255, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 1), 256, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 16), 260, new UInt256(0, 0, 0, 1));
+	}
+	public static IEnumerable<Func<(UInt256, int, UInt256)>> op_UnsignedShiftRightTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), 0, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0, 16), 1, new UInt256(0, 0, 0, 8));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 63, new UInt256(1, 0, 0, 0));
+		yield return () => (new UInt256(1, 2, 3, 4), 64, new UInt256(0, 1, 2, 3));
+		yield return () => (new UInt256(1, 0, 0, 0), 65, new UInt256(0, 0, 0x8000_0000_0000_0000, 0));
+		yield return () => (new UInt256(1, 0, 0, 0), 128, new UInt256(0, 0, 1, 0));
+		yield return () => (new UInt256(1, 0, 0, 0), 192, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 255, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 1), 256, new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 16), 260, new UInt256(0, 0, 0, 1));
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_EqualityTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, true);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 5), false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 4, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 3, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(2, 2, 3, 4), false);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_InequalityTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 5), true);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 4, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 3, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(2, 2, 3, 4), true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_LessThanTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(0, 9, 9, 9), new UInt256(1, 0, 0, 0), true);
+		yield return () => (new UInt256(2, 0, 0, 0), new UInt256(1, 9, 9, 9), false);
+		yield return () => (new UInt256(1, 1, 3, 4), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 1, 4), new UInt256(1, 2, 2, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 3), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 5), new UInt256(1, 2, 3, 4), false);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_LessThanOrEqualTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(0, 9, 9, 9), new UInt256(1, 0, 0, 0), true);
+		yield return () => (new UInt256(2, 0, 0, 0), new UInt256(1, 9, 9, 9), false);
+		yield return () => (new UInt256(1, 1, 3, 4), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 1, 4), new UInt256(1, 2, 2, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 3), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(1, 2, 3, 5), new UInt256(1, 2, 3, 4), false);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_GreaterThanTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(0, 9, 9, 9), new UInt256(1, 0, 0, 0), false);
+		yield return () => (new UInt256(2, 0, 0, 0), new UInt256(1, 9, 9, 9), true);
+		yield return () => (new UInt256(1, 1, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 1, 4), new UInt256(1, 2, 2, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 3), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 5), new UInt256(1, 2, 3, 4), true);
+	}
+	public static IEnumerable<Func<(UInt256, UInt256, bool)>> op_GreaterThanOrEqualTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), true);
+		yield return () => (new UInt256(0, 9, 9, 9), new UInt256(1, 0, 0, 0), false);
+		yield return () => (new UInt256(2, 0, 0, 0), new UInt256(1, 9, 9, 9), true);
+		yield return () => (new UInt256(1, 1, 3, 4), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 1, 4), new UInt256(1, 2, 2, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 3), new UInt256(1, 2, 3, 4), false);
+		yield return () => (new UInt256(1, 2, 3, 5), new UInt256(1, 2, 3, 4), true);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> AbsTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.One, UInt256.One);
+		yield return () => (UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (UInt256.MinValue, UInt256.MinValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsCanonicalTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsComplexNumberTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsEvenIntegerTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+		yield return () => (UInt256.One, false);
+		yield return () => (new UInt256(0, 0, 0, 2), true);
+		yield return () => (new UInt256(0, 0, 0, 3), false);
+		yield return () => (new UInt256(0, 0, 0, 0x8000_0000_0000_0000), true);
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), true);
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 1), false);
+		yield return () => (UInt256.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsFiniteTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsImaginaryNumberTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsInfinityTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsIntegerTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsNaNTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsNegativeTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsNegativeInfinityTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsNormalTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+		yield return () => (UInt256.One, true);
+		yield return () => (new UInt256(0, 0, 1, 0), true);
+		yield return () => (new UInt256(0, 1, 0, 0), true);
+		yield return () => (new UInt256(1, 0, 0, 0), true);
+		yield return () => (UInt256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsOddIntegerTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+		yield return () => (UInt256.One, true);
+		yield return () => (new UInt256(0, 0, 0, 2), false);
+		yield return () => (new UInt256(0, 0, 0, 3), true);
+		yield return () => (new UInt256(0, 0, 0, 0x8000_0000_0000_0000), false);
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), false);
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 1), true);
+		yield return () => (UInt256.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsPositiveTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsPositiveInfinityTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsRealNumberTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsSubnormalTestData()
+	{
+		yield return () => (UInt256.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsZeroTestData()
+	{
+		yield return () => (UInt256.Zero, true);
+		yield return () => (UInt256.One, false);
+		yield return () => (new UInt256(0, 0, 1, 0), false);
+		yield return () => (new UInt256(0, 1, 0, 0), false);
+		yield return () => (new UInt256(1, 0, 0, 0), false);
+		yield return () => (UInt256.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MaxMagnitudeTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MaxMagnitudeNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MinMagnitudeTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MinMagnitudeNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256, UInt256)>> MultiplyAddEstimateTestData()
+	{
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.Zero, UInt256.Zero);
+		yield return () => (UInt256.Zero, UInt256.Zero, UInt256.One, UInt256.One);
+		yield return () => (UInt256.One, UInt256.One, UInt256.One, new UInt256(0, 0, 0, 2));
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue), UInt256.One, new UInt256(0, 0, ulong.MaxValue - 1, 2));
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue - 1), new UInt256(0, 0, ulong.MaxValue - 1, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, UInt256)>> ParseTestData()
+	{
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, UInt256)>> ParseSpanTestData()
+	{
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, UInt256)>> ParseUtf8TestData()
+	{
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt256.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt256(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt256(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, UInt256)>> TryParseTestData()
+	{
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.MaxValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("1000000000000000000000000000000000000000000000000000000000000000000000000000000", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, UInt256)>> TryParseSpanTestData()
+	{
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.MaxValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("1000000000000000000000000000000000000000000000000000000000000000000000000000000".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, UInt256)>> TryParseUtf8TestData()
+	{
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt256(1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639935"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt256.MaxValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("1000000000000000000000000000000000000000000000000000000000000000000000000000000"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(UInt256, string, IFormatProvider?, string)>> ToStringTestData()
+	{
+		yield return () => ((UInt256)Int256.MaxValue, "e25", CultureInfo.InvariantCulture, "5.7896044618658097711785493e+76");
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256, UInt256)>> ClampTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 15), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 15));
+		yield return () => (new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 10));
+		yield return () => (new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 20));
+		yield return () => (new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 10));
+		yield return () => (new UInt256(0, 0, 0, 25), new UInt256(0, 0, 0, 10), new UInt256(0, 0, 0, 20), new UInt256(0, 0, 0, 20));
+		yield return () => (new UInt256(0, 0, 0, 25), new UInt256(0, 0, 0, 30), new UInt256(0, 0, 0, 20), default);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> CopySignTestData()
+	{
+		yield return () => (UInt256.MaxValue, UInt256.MaxValue, UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MaxTestData()
+	{
+		yield return () => (UInt256.One, UInt256.One, UInt256.One);
+		yield return () => (UInt256.MinValue, UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), UInt256.MaxValue, UInt256.MaxValue);
+		yield return () => (new UInt256(0, 0, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt256(0, 1, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 0, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 1, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt256(0, ulong.MaxValue, ulong.MaxValue, 0), new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt256(1, 0, 0, 0), new UInt256(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MaxNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MinTestData()
+	{
+		yield return () => (UInt256.One, UInt256.One, UInt256.One);
+		yield return () => (UInt256.MinValue, UInt256.MaxValue, UInt256.MinValue);
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue - 1), new UInt256(0, 0, 0, ulong.MaxValue - 1));
+		yield return () => (new UInt256(0, 0, 0, ulong.MaxValue), new UInt256(0, 0, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 0, 0, ulong.MaxValue));
+		yield return () => (new UInt256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(2, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, UInt256)>> MinNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt256, int)>> SignTestData()
+	{
+		yield return () => (UInt256.MaxValue, 1);
+		yield return () => (UInt256.Zero, 0);
+	}
+
+	public static IEnumerable<Func<(UInt256, bool)>> IsPow2TestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 1), true);
+		yield return () => (new UInt256(0, 0, 0, 2), true);
+		yield return () => (new UInt256(0, 0, 0, 4), true);
+		yield return () => (new UInt256(0, 0, 0, 8), true);
+		yield return () => (new UInt256(0, 0, 0, 16), true);
+		yield return () => (new UInt256(0, 0, 0, 1UL << 63), true);
+		yield return () => (new UInt256(1UL << 63, 0, 0, 0), true);
+		yield return () => (UInt256.Zero, false);
+		yield return () => (new UInt256(0, 0, 0, 3), false);
+		yield return () => (UInt256.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> Log2TestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 0, 2), new UInt256(0, 0, 0, 1));
+		yield return () => (new UInt256(0, 0, 0, 4), new UInt256(0, 0, 0, 2));
+		yield return () => (new UInt256(0, 0, 0, 8), new UInt256(0, 0, 0, 3));
+		yield return () => (new UInt256(0, 0, 0, 1UL << 63), new UInt256(0, 0, 0, 63));
+		yield return () => (new UInt256(0, 0, 1UL << 5, 0), new UInt256(0, 0, 0, 69));
+		yield return () => (new UInt256(0, 1UL << 42, 0, 0), new UInt256(0, 0, 0, 170));
+		yield return () => (new UInt256(1UL << 13, 0, 0, 0), new UInt256(0, 0, 0, 205));
+		yield return () => (new UInt256(1UL << 63, 0, 0, 0), new UInt256(0, 0, 0, 255));
+		yield return () => (new UInt256(0, 0, 0, 0), new UInt256(0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256, Pair<UInt256>)>> DivRemTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), UInt256.One, (new UInt256(1, 2, 3, 4), new UInt256(0, 0, 0, 0)));
+		yield return () => (new UInt256(1, 2, 3, 4), new UInt256(1, 2, 3, 4), (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 0)));
+		yield return () => (new UInt256(0, 0, 0, 5), new UInt256(0, 0, 0, 10), (new UInt256(0, 0, 0, 0), new UInt256(0, 0, 0, 5)));
+		yield return () => (new UInt256(0, 0, 0, 100), new UInt256(0, 0, 0, 30), (new UInt256(0, 0, 0, 3), new UInt256(0, 0, 0, 10)));
+		yield return () => (new UInt256(0, 1, 0, 0), new UInt256(0, 0, 1, 0), (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 0)));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> LeadingZeroCountTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), new UInt256(0, 0, 0, 256));
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 255));
+		yield return () => (new UInt256(0, 0, 1, 0), new UInt256(0, 0, 0, 191));
+		yield return () => (new UInt256(0, 1, 0, 0), new UInt256(0, 0, 0, 127));
+		yield return () => (new UInt256(1, 0, 0, 0), new UInt256(0, 0, 0, 63));
+		yield return () => (new UInt256(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt256(0, 0, 0, 63));
+		yield return () => (new UInt256(0, 0, 0, 1UL << 63), new UInt256(0, 0, 0, 192));
+		yield return () => (new UInt256(0, 0, 1UL << 63, 0), new UInt256(0, 0, 0, 128));
+		yield return () => (new UInt256(0, 1UL << 63, 0, 0), new UInt256(0, 0, 0, 64));
+		yield return () => (new UInt256(1UL << 63, 0, 0, 0), new UInt256(0, 0, 0, 0));
+		yield return () => (new UInt256(1UL << 62, 0, 0, 0), new UInt256(0, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> PopCountTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), new UInt256(0, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 1));
+		yield return () => (UInt256.MaxValue, new UInt256(0, 0, 0, 256));
+		yield return () => (new UInt256(ulong.MaxValue, 0, 0, 0), new UInt256(0, 0, 0, 64));
+		yield return () => (new UInt256(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), new UInt256(0, 0, 0, 128));
+		yield return () => (new UInt256(1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60), new UInt256(0, 0, 0, 4));
+	}
+
+	public static IEnumerable<Func<(byte[], bool, UInt256)>> ReadBigEndianTestData()
+	{
+		yield return () => ([], true, UInt256.Zero);
+		yield return () => ([0x01], true, UInt256.One);
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			Array.Fill(array, byte.MaxValue);
+			return (array, true, UInt256.MaxValue);
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[35];
+			for (int i = 3; i < 35; i++)
+				array[i] = byte.MaxValue;
+			return (array, true, UInt256.MaxValue);
+		};
+		yield return () => ([0x12, 0x34], true, new UInt256(0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			array[0] = 0x80;
+			return (array, true, new UInt256(1UL << 63, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(byte[], bool, UInt256)>> ReadLittleEndianTestData()
+	{
+		yield return () => ([], true, UInt256.Zero);
+		yield return () => ([0x01], true, UInt256.One);
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			Array.Fill(array, byte.MaxValue);
+			return (array, true, UInt256.MaxValue);
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[35];
+			for (int i = 0; i < 32; i++)
+				array[i] = byte.MaxValue;
+			return (array, true, UInt256.MaxValue);
+		};
+		yield return () => ([0x34, 0x12], true, new UInt256(0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[32];
+			array[31] = 0x80;
+			return (array, true, new UInt256(1UL << 63, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(UInt256, int, UInt256)>> RotateLeftTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), 0, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), 256, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0x8000_0000_0000_0000, 0), 64, new UInt256(0, 0x8000_0000_0000_0000, 0, 0));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 64, new UInt256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt256(0, 0, 0x8000_0000_0000_0000, 0), 128, new UInt256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 128, new UInt256(0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(UInt256, int, UInt256)>> RotateRightTestData()
+	{
+		yield return () => (new UInt256(1, 2, 3, 4), 0, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(1, 2, 3, 4), 256, new UInt256(1, 2, 3, 4));
+		yield return () => (new UInt256(0, 0, 0x8000_0000_0000_0000, 0), 64, new UInt256(0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt256(0, 0, 0, 0x8000_0000_0000_0000), 64, new UInt256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 0x8000_0000_0000_0000, 0), 128, new UInt256(0x8000_0000_0000_0000, 0, 0, 0));
+		yield return () => (new UInt256(0x8000_0000_0000_0000, 0, 0, 0), 128, new UInt256(0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt256)>> TrailingZeroCountTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), new UInt256(0, 0, 0, 256));
+		yield return () => (new UInt256(0, 0, 0, 1), new UInt256(0, 0, 0, 0));
+		yield return () => (new UInt256(0, 0, 8, 0), new UInt256(0, 0, 0, 67));
+		yield return () => (new UInt256(0, 0x10, 0, 0), new UInt256(0, 0, 0, 132));
+		yield return () => (new UInt256(0x200, 0, 0, 0), new UInt256(0, 0, 0, 201));
+	}
+
+	public static IEnumerable<Func<(UInt256, int)>> GetByteCountTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), Unsafe.SizeOf<UInt256>());
+	}
+
+	public static IEnumerable<Func<(UInt256, int)>> GetShortestBitLengthTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), 0);
+		yield return () => (new UInt256(0, 0, 0, 1), 1);
+		yield return () => (new UInt256(1, 0, 0, 0), 193);
+		yield return () => (UInt256.MaxValue, 256);
+	}
+
+	public static IEnumerable<Func<(UInt256, byte[], int)>> WriteBigEndianTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), new byte[32], Unsafe.SizeOf<UInt256>());
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 31; i++)
+				buffer[i] = 0;
+
+			buffer[31] = 1;
+			
+			return (new UInt256(0, 0, 0, 1), buffer, Unsafe.SizeOf<UInt256>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 32; i++)
+				buffer[i] = 0xFF;
+			
+			return (UInt256.MaxValue, buffer, Unsafe.SizeOf<UInt256>());
+		};
+	}
+
+	public static IEnumerable<Func<(UInt256, byte[], int)>> WriteLittleEndianTestData()
+	{
+		yield return () => (new UInt256(0, 0, 0, 0), new byte[32], Unsafe.SizeOf<UInt256>());
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			buffer[0] = 1;
+			for (int i = 1; i < 32; i++)
+				buffer[i] = 0;
+			
+			return (new UInt256(0, 0, 0, 1), buffer, Unsafe.SizeOf<UInt256>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[32];
+			
+			for (int i = 0; i < 32; i++)
+				buffer[i] = 0xFF;
+			
+			return (UInt256.MaxValue, buffer, Unsafe.SizeOf<UInt256>());
+		};
+	}
+
+	public static IEnumerable<Func<(UInt256, byte)>> ConvertToCheckedByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, byte)>> ConvertToSaturatingByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.MaxValue, byte.MaxValue);
+		yield return () => (UInt256.ByteMaxValue + UInt256.One, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, byte)>> ConvertToTruncatingByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.MaxValue, byte.MaxValue);
+		yield return () => (UInt256.ByteMaxValue + UInt256.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt256, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue + UInt256.One, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue + UInt256.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt256, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue + UInt256.One, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue + UInt256.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt256, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		yield return () => (UInt256.One, 1U);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		yield return () => (UInt256.One, 1U);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue + UInt256.One, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		yield return () => (UInt256.One, 1U);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue + UInt256.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		yield return () => (UInt256.One, UInt128.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		yield return () => (UInt256.One, UInt128.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue + UInt256.One, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		yield return () => (UInt256.One, UInt128.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue + UInt256.One, UInt128.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt256, UInt512)>> ConvertToCheckedUInt512TestData()
+	{
+		yield return () => (UInt256.One, UInt512.One);
+		yield return () => (UInt256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (UInt256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (UInt256.MaxValue, UInt512.UInt256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, UInt512)>> ConvertToSaturatingUInt512TestData()
+	{
+		yield return () => (UInt256.One, UInt512.One);
+		yield return () => (UInt256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (UInt256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (UInt256.MaxValue, UInt512.UInt256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, UInt512)>> ConvertToTruncatingUInt512TestData()
+	{
+		yield return () => (UInt256.One, UInt512.One);
+		yield return () => (UInt256.ByteMaxValue, UInt512.ByteMaxValue);
+		yield return () => (UInt256.UInt16MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (UInt256.MaxValue, UInt512.UInt256MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.MaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue + UInt256.One, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.MaxValue, unchecked((sbyte)0xFF));
+		yield return () => (UInt256.SByteMaxValue + UInt256.One, unchecked((sbyte)0x80));
+	}
+
+	public static IEnumerable<Func<(UInt256, short)>> ConvertToCheckedInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, short)>> ConvertToSaturatingInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int16MaxValue + UInt256.One, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, short)>> ConvertToTruncatingInt16TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.MaxValue, unchecked((short)0xFFFF));
+		yield return () => (UInt256.Int16MaxValue + UInt256.One, unchecked((short)0x8000));
+	}
+
+	public static IEnumerable<Func<(UInt256, int)>> ConvertToCheckedInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, int)>> ConvertToSaturatingInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int32MaxValue + UInt256.One, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, int)>> ConvertToTruncatingInt32TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.MaxValue, unchecked((int)0xFFFF_FFFF));
+		yield return () => (UInt256.Int32MaxValue + UInt256.One, unchecked((int)0x8000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt256, long)>> ConvertToCheckedInt64TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, long)>> ConvertToSaturatingInt64TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.MaxValue, long.MaxValue);
+		yield return () => (UInt256.Int64MaxValue + UInt256.One, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, long)>> ConvertToTruncatingInt64TestData()
+	{
+		yield return () => (UInt256.One, 1);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.MaxValue, unchecked((long)0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt256.Int64MaxValue + UInt256.One, unchecked((long)0x8000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt256, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		yield return () => (UInt256.One, Int128.One);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		yield return () => (UInt256.One, Int128.One);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (UInt256.MaxValue, Int128.MaxValue);
+		yield return () => (UInt256.Int128MaxValue + UInt256.One, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		yield return () => (UInt256.One, Int128.One);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int128.MaxValue);
+		yield return () => (UInt256.MaxValue, new Int128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt256.Int128MaxValue + UInt256.One, new Int128(0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt256, Int256)>> ConvertToCheckedInt256TestData()
+	{
+		yield return () => (UInt256.One, Int256.One);
+		yield return () => (UInt256.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int256)>> ConvertToSaturatingInt256TestData()
+	{
+		yield return () => (UInt256.One, Int256.One);
+		yield return () => (UInt256.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int256.MaxValue);
+		yield return () => (UInt256.MaxValue, Int256.MaxValue);
+		yield return () => (UInt256.Int256MaxValue + UInt256.One, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int256)>> ConvertToTruncatingInt256TestData()
+	{
+		yield return () => (UInt256.One, Int256.One);
+		yield return () => (UInt256.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int256.MaxValue);
+		yield return () => (UInt256.MaxValue, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt256.Int256MaxValue + UInt256.One, new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt256, Int512)>> ConvertToCheckedInt512TestData()
+	{
+		yield return () => (UInt256.One, Int512.One);
+		yield return () => (UInt256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt256.MaxValue, Int512.UInt256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int512)>> ConvertToSaturatingInt512TestData()
+	{
+		yield return () => (UInt256.One, Int512.One);
+		yield return () => (UInt256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt256.MaxValue, Int512.UInt256MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Int512)>> ConvertToTruncatingInt512TestData()
+	{
+		yield return () => (UInt256.One, Int512.One);
+		yield return () => (UInt256.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt256.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt256.MaxValue, Int512.UInt256MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		yield return () => (UInt256.One, BigInteger.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+	}
+
+	public static IEnumerable<Func<(UInt256, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		yield return () => (UInt256.One, BigInteger.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+	}
+
+	public static IEnumerable<Func<(UInt256, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		yield return () => (UInt256.One, BigInteger.One);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt256.MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+	}
+
+	public static IEnumerable<Func<(UInt256, Half)>> ConvertToCheckedHalfTestData()
+	{
+		yield return () => (UInt256.One, Half.One);
+		yield return () => (UInt256.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, (Half)short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		yield return () => (UInt256.One, Half.One);
+		yield return () => (UInt256.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Half.MaxValue);
+		yield return () => (UInt256.MaxValue, Half.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		yield return () => (UInt256.One, Half.One);
+		yield return () => (UInt256.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Half.MaxValue);
+		yield return () => (UInt256.MaxValue, Half.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, float)>> ConvertToCheckedSingleTestData()
+	{
+		yield return () => (UInt256.One, 1f);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, float)>> ConvertToSaturatingSingleTestData()
+	{
+		yield return () => (UInt256.One, 1f);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, float)>> ConvertToTruncatingSingleTestData()
+	{
+		yield return () => (UInt256.One, 1f);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, double)>> ConvertToCheckedDoubleTestData()
+	{
+		yield return () => (UInt256.One, 1d);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt256.MaxValue, 115792089237316195423570985008687907853269984665640564039457584007913129639935.0d);
+		
+		yield return () => (UInt256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+	}
+	
+	public static IEnumerable<Func<(UInt256, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		yield return () => (UInt256.One, 1d);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt256.MaxValue, 115792089237316195423570985008687907853269984665640564039457584007913129639935.0d);
+		
+		yield return () => (UInt256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+	}
+	
+	public static IEnumerable<Func<(UInt256, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		yield return () => (UInt256.One, 1d);
+		yield return () => (UInt256.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt256.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt256.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt256.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt256.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt256.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt256.MaxValue, 115792089237316195423570985008687907853269984665640564039457584007913129639935.0d);
+		
+		yield return () => (UInt256.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+	}
+
+	public static IEnumerable<Func<(UInt256, Quad)>> ConvertToCheckedQuadTestData()
+	{
+		yield return () => (UInt256.One, Quad.One);
+		yield return () => (UInt256.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Quad)>> ConvertToSaturatingQuadTestData()
+	{
+		yield return () => (UInt256.One, Quad.One);
+		yield return () => (UInt256.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Quad)>> ConvertToTruncatingQuadTestData()
+	{
+		yield return () => (UInt256.One, Quad.One);
+		yield return () => (UInt256.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt256, Octo)>> ConvertToCheckedOctoTestData()
+	{
+		yield return () => (UInt256.One, Octo.One);
+		yield return () => (UInt256.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Octo)>> ConvertToSaturatingOctoTestData()
+	{
+		yield return () => (UInt256.One, Octo.One);
+		yield return () => (UInt256.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt256, Octo)>> ConvertToTruncatingOctoTestData()
+	{
+		yield return () => (UInt256.One, Octo.One);
+		yield return () => (UInt256.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt256.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt256.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt256.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt256.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt256.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt256.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt256.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt256.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt256.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(byte, UInt256)>> ConvertFromCheckedByteTestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, UInt256)>> ConvertFromSaturatingByteTestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, UInt256)>> ConvertFromTruncatingByteTestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(ushort, UInt256)>> ConvertFromCheckedUInt16TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, UInt256)>> ConvertFromSaturatingUInt16TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, UInt256)>> ConvertFromTruncatingUInt16TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(uint, UInt256)>> ConvertFromCheckedUInt32TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, UInt256)>> ConvertFromSaturatingUInt32TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, UInt256)>> ConvertFromTruncatingUInt32TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+
+	public static IEnumerable<Func<(ulong, UInt256)>> ConvertFromCheckedUInt64TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, UInt256)>> ConvertFromSaturatingUInt64TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, UInt256)>> ConvertFromTruncatingUInt64TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt128, UInt256)>> ConvertFromCheckedUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt256.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, UInt256)>> ConvertFromSaturatingUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt256.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, UInt256)>> ConvertFromTruncatingUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt256.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(sbyte, UInt256)>> ConvertFromCheckedSByteTestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, UInt256)>> ConvertFromSaturatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, UInt256.Zero);
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, UInt256)>> ConvertFromTruncatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(short, UInt256)>> ConvertFromCheckedInt16TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, UInt256)>> ConvertFromSaturatingInt16TestData()
+	{
+		yield return () => (short.MinValue, UInt256.Zero);
+		yield return () => (sbyte.MinValue, UInt256.Zero);
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, UInt256)>> ConvertFromTruncatingInt16TestData()
+	{
+		yield return () => (short.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+	}
+
+	public static IEnumerable<Func<(int, UInt256)>> ConvertFromCheckedInt32TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, UInt256)>> ConvertFromSaturatingInt32TestData()
+	{
+		yield return () => (int.MinValue, UInt256.Zero);
+		yield return () => (short.MinValue, UInt256.Zero);
+		yield return () => (sbyte.MinValue, UInt256.Zero);
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, UInt256)>> ConvertFromTruncatingInt32TestData()
+	{
+		yield return () => (int.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+	}
+
+	public static IEnumerable<Func<(long, UInt256)>> ConvertFromCheckedInt64TestData()
+	{
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, UInt256)>> ConvertFromSaturatingInt64TestData()
+	{
+		yield return () => (long.MinValue, UInt256.Zero);
+		yield return () => (int.MinValue, UInt256.Zero);
+		yield return () => (short.MinValue, UInt256.Zero);
+		yield return () => (sbyte.MinValue, UInt256.Zero);
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, UInt256)>> ConvertFromTruncatingInt64TestData()
+	{
+		yield return () => (long.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
+		yield return () => (int.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int128, UInt256)>> ConvertFromCheckedInt128TestData()
+	{
+		yield return () => (Int128.One, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt256.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, UInt256)>> ConvertFromSaturatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, UInt256.Zero);
+		yield return () => (long.MinValue, UInt256.Zero);
+		yield return () => (int.MinValue, UInt256.Zero);
+		yield return () => (short.MinValue, UInt256.Zero);
+		yield return () => (sbyte.MinValue, UInt256.Zero);
+		yield return () => (Int128.One, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt256.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, UInt256)>> ConvertFromTruncatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (long.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
+		yield return () => (int.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (Int128.One, UInt256.One);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt256.Int128MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, UInt256)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt256.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt256.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, UInt256)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt256.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt256.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt256.MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639936"), UInt256.MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"), UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, UInt256)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt256.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt256.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt256.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt256.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt256.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt256.MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639936"), UInt256.Zero);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"), UInt256.MaxValue);
+	}
+
+	public static IEnumerable<Func<(Half, UInt256)>> ConvertFromCheckedHalfTestData()
+	{
+		yield return () => (Half.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, UInt256)>> ConvertFromSaturatingHalfTestData()
+	{
+		yield return () => (Half.MinValue, UInt256.Zero);
+		yield return () => (Half.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, UInt256)>> ConvertFromTruncatingHalfTestData()
+	{
+		yield return () => (Half.MinValue, UInt256.Zero);
+		yield return () => (Half.One, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(float, UInt256)>> ConvertFromCheckedSingleTestData()
+	{
+		yield return () => (1f, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, UInt256)>> ConvertFromSaturatingSingleTestData()
+	{
+		yield return () => (float.MinValue, UInt256.Zero);
+		yield return () => (1f, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, UInt256)>> ConvertFromTruncatingSingleTestData()
+	{
+		yield return () => (float.MinValue, UInt256.Zero);
+		yield return () => (1f, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(double, UInt256)>> ConvertFromCheckedDoubleTestData()
+	{
+		yield return () => (1d, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, UInt256)>> ConvertFromSaturatingDoubleTestData()
+	{
+		yield return () => (double.MinValue, UInt256.Zero);
+		yield return () => (1d, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, UInt256)>> ConvertFromTruncatingDoubleTestData()
+	{
+		yield return () => (double.MinValue, UInt256.Zero);
+		yield return () => (1d, UInt256.One);
+		yield return () => (byte.MaxValue, UInt256.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt256.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt256.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt256.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt256.UInt32MaxValue);
+	}
+}
diff --git a/src/MissingValues.Tests/Data/UInt512DataSources.cs b/src/MissingValues.Tests/Data/UInt512DataSources.cs
new file mode 100644
index 0000000..cebb631
--- /dev/null
+++ b/src/MissingValues.Tests/Data/UInt512DataSources.cs
@@ -0,0 +1,2084 @@
+using MissingValues.Tests.Data.Sources;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using MissingValues.Tests.Extensions;
+
+namespace MissingValues.Tests.Data;
+
+public class UInt512DataSources
+	: IMathOperatorsDataSource<UInt512>,
+	IShiftOperatorsDataSource<UInt512>,
+	IBitwiseOperatorsDataSource<UInt512>,
+	IEqualityOperatorsDataSource<UInt512>,
+	IComparisonOperatorsDataSource<UInt512>,
+	INumberBaseDataSource<UInt512>,
+	INumberDataSource<UInt512>,
+	IBinaryNumberDataSource<UInt512>,
+	IBinaryIntegerDataSource<UInt512>
+{
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_AdditionTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.Zero, UInt512.One);
+		yield return () => (UInt512.One, UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => (new UInt512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), UInt512.One, new UInt512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (UInt512.One, UInt512.MaxValue, UInt512.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512, bool)>> op_CheckedAdditionTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero, false);
+		yield return () => (UInt512.One, UInt512.Zero, UInt512.One, false);
+		yield return () => (UInt512.One, UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 1, 0), false);
+		yield return () => (new UInt512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), UInt512.One, new UInt512(1, 0, 0, 0, 0, 0, 0, 0), false);
+		yield return () => (UInt512.One, UInt512.MaxValue, UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_CheckedDecrementTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.MaxValue, true);
+		yield return () => (UInt512.One, UInt512.Zero, false);
+		yield return () => (UInt512.MaxValue, UInt512.MaxValue - UInt512.One, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_CheckedIncrementTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.One, false);
+		yield return () => (UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 0, 2), false);
+		yield return () => (UInt512.MaxValue, UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512, bool)>> op_CheckedMultiplyTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero, false);
+		yield return () => (UInt512.One, UInt512.One, UInt512.One, false);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 3),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 6),
+			false
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			new UInt512(0, 0, 0, 0, 0, 1, 0, 0),
+			false
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 1, 0, 0, 0, 0),
+			new UInt512(0, 0, 0, 0, 1, 0, 0, 0),
+			new UInt512(1, 0, 0, 0, 0, 0, 0, 0),
+			false
+		);
+		yield return () => (
+			UInt512.MaxValue,
+			UInt512.One,
+			UInt512.MaxValue,
+			false
+		);
+		yield return () => (
+			UInt512.MaxValue,
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			default,
+			true
+		);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512, bool)>> op_CheckedSubtractionTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero, false);
+		yield return () => (UInt512.One, UInt512.Zero, UInt512.One, false);
+		yield return () => (UInt512.One, UInt512.One, UInt512.Zero, false);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), UInt512.One, UInt512.One, false);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			UInt512.One,
+			new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue),
+			false
+		);
+		yield return () => (UInt512.Zero, UInt512.One, UInt512.MaxValue, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> op_DecrementTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.MaxValue);
+		yield return () => (UInt512.One, UInt512.Zero);
+		yield return () => (UInt512.MaxValue, UInt512.MaxValue - UInt512.One);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_DivisionTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.One, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.One, UInt512.One);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 6),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 3)
+		);
+		yield return () => (UInt512.MaxValue, UInt512.One, UInt512.MaxValue);
+		yield return () => (UInt512.MaxValue, new UInt512(0, 0, 0, 0, 0, 1, 0, 0), new UInt512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue - 1),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue)
+		);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> op_IncrementTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.One);
+		yield return () => (UInt512.One, new UInt512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (UInt512.MaxValue, UInt512.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_ModulusTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.One, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.One, UInt512.Zero);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 5),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			UInt512.One
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 7),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 3),
+			UInt512.One
+		);
+		yield return () => (UInt512.MaxValue, UInt512.One, UInt512.Zero);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue),
+			UInt512.One
+		);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_MultiplyTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.One, UInt512.One);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 3),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 6)
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue),
+			new UInt512(0, 0, 0, 0, 0, 0, 0, 2),
+			new UInt512(0, 0, 0, 0, 0, 0, 1, ulong.MaxValue - 1)
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			new UInt512(0, 0, 0, 0, 0, 1, 0, 0)
+		);
+		yield return () => (
+			new UInt512(0, 0, 0, 1, 0, 0, 0, 0),
+			new UInt512(0, 0, 0, 0, 1, 0, 0, 0),
+			new UInt512(1, 0, 0, 0, 0, 0, 0, 0)
+		);
+		yield return () => (UInt512.MaxValue, UInt512.One, UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_SubtractionTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.Zero, UInt512.One);
+		yield return () => (UInt512.One, UInt512.One, UInt512.Zero);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), UInt512.One, UInt512.One);
+		yield return () => (
+			new UInt512(0, 0, 0, 0, 0, 0, 1, 0),
+			UInt512.One,
+			new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue)
+		);
+		yield return () => (
+			UInt512.MaxValue,
+			UInt512.One,
+			new UInt512(ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue,
+				ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue - 1)
+		);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> op_UnaryNegationTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_CheckedUnaryNegationTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, int, UInt512)>> op_ShiftLeftTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 0, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 1, new UInt512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 63, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 64, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 128, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 256, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 511, new UInt512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 512, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 513, new UInt512(0, 0, 0, 0, 0, 0, 0, 2));
+	}
+
+	public static IEnumerable<Func<(UInt512, int, UInt512)>> op_ShiftRightTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 0, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), 1, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000), 63, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1, 0), 64, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, 0, 0), 128, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 1, 0, 0, 0, 0), 256, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0), 511, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 512, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), 513, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(UInt512, int, UInt512)>> op_UnsignedShiftRightTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 0, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), 1, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000), 63, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1, 0), 64, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, 0, 0), 128, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 1, 0, 0, 0, 0), 256, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0), 511, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 512, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), 513, new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_BitwiseAndTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.Zero, UInt512.MaxValue, UInt512.Zero);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), UInt512.MaxValue, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_BitwiseOrTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.Zero, UInt512.MaxValue, UInt512.MaxValue);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), UInt512.MaxValue, UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> op_BitwiseXorTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.Zero, UInt512.MaxValue, UInt512.MaxValue);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), UInt512.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> op_OnesComplementTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.MaxValue);
+		yield return () => (UInt512.MaxValue, UInt512.Zero);
+		yield return () => (new UInt512(0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555), new UInt512(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 0x5555555555555555, 0xAAAAAAAAAAAAAAAA));
+		yield return () => (new UInt512(0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0x0123456789ABCDEF, 0xFEDCBA9876543210, 0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0), new UInt512(~0x0123456789ABCDEFU, ~0xFEDCBA9876543210U, ~0x0F0F0F0F0F0F0F0FU, ~0xF0F0F0F0F0F0F0F0U, ~0x0123456789ABCDEFU, ~0xFEDCBA9876543210U, ~0x0F0F0F0F0F0F0F0FU, ~0xF0F0F0F0F0F0F0F0U));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_EqualityTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_InequalityTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_GreaterThanOrEqualTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_GreaterThanTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_LessThanOrEqualTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, bool)>> op_LessThanTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 5, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 7, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 4, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 5, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 1, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 3, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 9), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 5, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 7, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 3, 4, 4, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 2, 3, 5, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(1, 2, 1, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+		yield return () => (new UInt512(1, 3, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), false);
+		yield return () => (new UInt512(0, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> AbsTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.One, UInt512.One);
+		yield return () => (UInt512.MaxValue, UInt512.MaxValue);
+		yield return () => (UInt512.MinValue, UInt512.MinValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsCanonicalTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsComplexNumberTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsEvenIntegerTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+		
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsFiniteTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsImaginaryNumberTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsInfinityTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsIntegerTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsNaNTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsNegativeTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsNegativeInfinityTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsNormalTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+		yield return () => (UInt512.One, true);
+		yield return () => (UInt512.MaxValue, true);
+		yield return () => (UInt512.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsOddIntegerTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+		yield return () => (UInt512.One, true);
+		yield return () => (UInt512.MaxValue, true);
+		yield return () => (UInt512.MinValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsPositiveTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsPositiveInfinityTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsRealNumberTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsSubnormalTestData()
+	{
+		yield return () => (UInt512.Zero, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsZeroTestData()
+	{
+		yield return () => (UInt512.Zero, true);
+		yield return () => (UInt512.One, false);
+		yield return () => (UInt512.MaxValue, false);
+		yield return () => (UInt512.MinValue, true);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MaxMagnitudeTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MaxMagnitudeNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MinMagnitudeTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MinMagnitudeNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512, UInt512)>> MultiplyAddEstimateTestData()
+	{
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.Zero, UInt512.Zero);
+		yield return () => (UInt512.Zero, UInt512.Zero, UInt512.One, UInt512.One);
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, UInt512)>> ParseTestData()
+	{
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656", NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095", NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF", 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, UInt512)>> ParseSpanTestData()
+	{
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF".ToCharArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111".ToCharArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, UInt512)>> ParseUtf8TestData()
+	{
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 0, 1, 0, 0, 0, 0, 0));
+		yield return () => ("39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306816"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(0, 1, 0, 0, 0, 0, 0, 0));
+		yield return () => ("726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614656"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, new UInt512(1, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, UInt512.MaxValue);
+		
+		yield return () => ("123456789ABCDEF0"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x123456789ABCDEF0));
+		yield return () => ("FF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFF));
+		yield return () => ("FFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFF));
+		yield return () => ("FFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF00000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
+		yield return () => ("FFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF"u8.ToArray(), 
+			NumberStyles.HexNumber, CultureInfo.InvariantCulture, new UInt512(0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF));
+		
+		yield return () => ("1010101010101010"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1010101010101010));
+		yield return () => ("11111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111));
+		yield return () => ("1111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111));
+		yield return () => ("11111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b11111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0, 0, 0, 0, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+		yield return () => ("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"u8.ToArray(), 
+			NumberStyles.BinaryNumber, CultureInfo.InvariantCulture, new UInt512(0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111, 0b1111111111111111111111111111111111111111111111111111111111111111));
+	}
+
+	public static IEnumerable<Func<(string, NumberStyles, IFormatProvider?, bool, UInt512)>> TryParseTestData()
+	{
+		yield return () => ("0", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.Zero);
+		yield return () => ("1", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.One);
+		yield return () => ("4294967296", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936", NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095", NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.MaxValue);
+		yield return () => ("-1", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(char[], NumberStyles, IFormatProvider?, bool, UInt512)>> TryParseSpanTestData()
+	{
+		yield return () => ("0".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.Zero);
+		yield return () => ("1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.One);
+		yield return () => ("4294967296".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.MaxValue);
+		yield return () => ("-1".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".ToCharArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(byte[], NumberStyles, IFormatProvider?, bool, UInt512)>> TryParseUtf8TestData()
+	{
+		yield return () => ("0"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.Zero);
+		yield return () => ("1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.One);
+		yield return () => ("4294967296"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 0, 4294967296));
+		yield return () => ("18446744073709551616"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 0, 1, 0));
+		yield return () => ("340282366920938463463374607431768211456"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => ("6277101735386680763835789423207666416102355444464034512896"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 0, 1, 0, 0, 0));
+		yield return () => ("115792089237316195423570985008687907853269984665640564039457584007913129639936"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, new UInt512(0, 0, 0, 1, 0, 0, 0, 0));
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, true, UInt512.MaxValue);
+		yield return () => ("-1"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("2.25"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+		yield return () => ("20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"u8.ToArray(), NumberStyles.Integer, CultureInfo.InvariantCulture, false, default);
+	}
+
+	public static IEnumerable<Func<(UInt512, string, IFormatProvider?, string)>> ToStringTestData()
+	{
+		yield return () => ((UInt512)Int256.MaxValue, "e25", CultureInfo.InvariantCulture, "5.7896044618658097711785493e+76");
+		yield return () => ((UInt512)Int512.MaxValue, "e25", CultureInfo.InvariantCulture, "6.7039039649712985497870125e+153");
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512, UInt512)>> ClampTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 15), new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 15));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 10));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 20));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 05), new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 10));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 25), new UInt512(0, 0, 0, 0, 0, 0, 0, 10), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), new UInt512(0, 0, 0, 0, 0, 0, 0, 20));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 25), new UInt512(0, 0, 0, 0, 0, 0, 0, 30), new UInt512(0, 0, 0, 0, 0, 0, 0, 20), default);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> CopySignTestData()
+	{
+		yield return () => (UInt512.MaxValue, UInt512.MaxValue, UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MaxTestData()
+	{
+		yield return () => (UInt512.One, UInt512.One, UInt512.One);
+		yield return () => (UInt512.MinValue, UInt512.MaxValue, UInt512.MaxValue);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), UInt512.MaxValue, UInt512.MaxValue);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 1, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 1, 0, 0));
+		yield return () => (new UInt512(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt512(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MaxNumberTestData()
+	{
+		return MaxTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MinTestData()
+	{
+		yield return () => (UInt512.One, UInt512.One, UInt512.One);
+		yield return () => (UInt512.MinValue, UInt512.MaxValue, UInt512.MinValue);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), UInt512.MaxValue, new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, 0, ulong.MaxValue));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue), new UInt512(0, 0, 0, 0, 0, 0, ulong.MaxValue, ulong.MaxValue));
+		yield return () => (new UInt512(1, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue), new UInt512(0, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, UInt512)>> MinNumberTestData()
+	{
+		return MinTestData();
+	}
+
+	public static IEnumerable<Func<(UInt512, int)>> SignTestData()
+	{
+		yield return () => (UInt512.MaxValue, 1);
+		yield return () => (UInt512.Zero, 0);
+	}
+
+	public static IEnumerable<Func<(UInt512, bool)>> IsPow2TestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 4), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 8), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 16), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1UL << 63), true);
+		yield return () => (new UInt512(0, 0, 0, 0, 1UL << 63, 0, 0, 0), true);
+		yield return () => (new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), true);
+		yield return () => (UInt512.Zero, false);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 3), false);
+		yield return () => (UInt512.MaxValue, false);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> Log2TestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 2), new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 4), new UInt512(0, 0, 0, 0, 0, 0, 0, 2));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 8), new UInt512(0, 0, 0, 0, 0, 0, 0, 3));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1UL << 63), new UInt512(0, 0, 0, 0, 0, 0, 0, 63));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1UL << 5, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 69));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 1UL << 42, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 170));
+		yield return () => (new UInt512(0, 0, 0, 0, 1UL << 13, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 205));
+		yield return () => (new UInt512(0, 0, 0, 0, 1UL << 63, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 255));
+		yield return () => (new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 511));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512, Pair<UInt512>)>> DivRemTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 0, 0, 0, 0, 0, 0, 1), (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 8), (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 0)));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), new UInt512(1, 2, 3, 4, 5, 6, 7, 9), (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new UInt512(1, 2, 3, 4, 5, 6, 7, 8)));
+		yield return () => (UInt512.MaxValue, UInt256.MaxValue, (new UInt512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001), UInt512.Zero));
+		yield return () => (UInt512.MaxValue, new UInt512(0, 0, 0, 1, 0, 0, 0, 0), (new UInt512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF), new UInt512(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF)));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> LeadingZeroCountTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 512));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 511));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 447));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1UL << 36, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 411));
+		yield return () => (new UInt512(0, 0, 0, 1, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 255));
+		yield return () => (new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> PopCountTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 1));
+		yield return () => (UInt512.MaxValue, new UInt512(0, 0, 0, 0, 0, 0, 0, 512));
+		yield return () => (new UInt512(ulong.MaxValue, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 64));
+		yield return () => (new UInt512(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA), new UInt512(0, 0, 0, 0, 0, 0, 0, 256));
+		yield return () => (new UInt512(0, 0, 0, 0, 1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60), new UInt512(0, 0, 0, 0, 0, 0, 0, 4));
+		yield return () => (new UInt512(1UL << 63, 1UL << 62, 1UL << 61, 1UL << 60, 1UL << 59, 1UL << 58, 1UL << 57, 1UL << 56), new UInt512(0, 0, 0, 0, 0, 0, 0, 8));
+	}
+
+	public static IEnumerable<Func<(byte[], bool, UInt512)>> ReadBigEndianTestData()
+	{
+		yield return () => ([], true, UInt512.Zero);
+		yield return () => ([0x01], true, UInt512.One);
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			Array.Fill(array, byte.MaxValue);
+			return (array, true, UInt512.MaxValue);
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[67];
+			for (int i = 3; i < 67; i++)
+				array[i] = byte.MaxValue;
+			return (array, true, UInt512.MaxValue);
+		};
+		yield return () => ([0x12, 0x34], true, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			array[0] = 0x80;
+			return (array, true, new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(byte[], bool, UInt512)>> ReadLittleEndianTestData()
+	{
+		yield return () => ([], true, UInt512.Zero);
+		yield return () => ([0x01], true, UInt512.One);
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			Array.Fill(array, byte.MaxValue);
+			return (array, true, UInt512.MaxValue);
+		};
+		yield return () =>
+		{
+			byte[] array = new byte[67];
+			for (int i = 0; i < 64; i++)
+				array[i] = byte.MaxValue;
+			return (array, true, UInt512.MaxValue);
+		};
+		yield return () => ([0x34, 0x12], true, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x1234));
+		yield return () =>
+		{
+			byte[] array = new byte[64];
+			array[63] = 0x80;
+			return (array, true, new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0));
+		};
+	}
+
+	public static IEnumerable<Func<(UInt512, int, UInt512)>> RotateLeftTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 0, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 512, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0), 64, new UInt512(0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0));
+		yield return () => (new UInt512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0), 64, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt512(0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0, 0), 128, new UInt512(0, 0, 0x8000_0000_0000_0000, 0, 0, 0, 0, 0));
+	}
+
+	public static IEnumerable<Func<(UInt512, int, UInt512)>> RotateRightTestData()
+	{
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 0, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(1, 2, 3, 4, 5, 6, 7, 8), 512, new UInt512(1, 2, 3, 4, 5, 6, 7, 8));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0), 64, new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000), 64, new UInt512(0x8000_0000_0000_0000, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0x8000_0000_0000_0000, 0, 0, 0), 128, new UInt512(0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000, 0));
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt512)>> TrailingZeroCountTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 512));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), new UInt512(0, 0, 0, 0, 0, 0, 0, 0));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 64));
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 1UL << 36, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 100));
+		yield return () => (new UInt512(0, 0, 0, 1, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 256));
+		yield return () => (new UInt512(1UL << 63, 0, 0, 0, 0, 0, 0, 0), new UInt512(0, 0, 0, 0, 0, 0, 0, 511));
+	}
+
+	public static IEnumerable<Func<(UInt512, int)>> GetByteCountTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), Unsafe.SizeOf<UInt512>());
+	}
+
+	public static IEnumerable<Func<(UInt512, int)>> GetShortestBitLengthTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), 0);
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), 1);
+		yield return () => (new UInt512(0, 0, 0, 0, 1, 0, 0, 0), 193);
+		yield return () => (new UInt512(1, 0, 0, 0, 0, 0, 0, 0), 449);
+		yield return () => (UInt512.MaxValue, 512);
+	}
+
+	public static IEnumerable<Func<(UInt512, byte[], int)>> WriteBigEndianTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new byte[64], Unsafe.SizeOf<UInt512>());
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 63; i++)
+				buffer[i] = 0;
+
+			buffer[63] = 1;
+			
+			return (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), buffer, Unsafe.SizeOf<UInt512>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 64; i++)
+				buffer[i] = 0xFF;
+			
+			return (UInt512.MaxValue, buffer, Unsafe.SizeOf<UInt512>());
+		};
+	}
+
+	public static IEnumerable<Func<(UInt512, byte[], int)>> WriteLittleEndianTestData()
+	{
+		yield return () => (new UInt512(0, 0, 0, 0, 0, 0, 0, 0), new byte[64], Unsafe.SizeOf<UInt512>());
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			buffer[0] = 1;
+			for (int i = 1; i < 64; i++)
+				buffer[i] = 0;
+			
+			return (new UInt512(0, 0, 0, 0, 0, 0, 0, 1), buffer, Unsafe.SizeOf<UInt512>());
+		};
+		yield return () =>
+		{
+			var buffer = new byte[64];
+			
+			for (int i = 0; i < 64; i++)
+				buffer[i] = 0xFF;
+			
+			return (UInt512.MaxValue, buffer, Unsafe.SizeOf<UInt512>());
+		};
+	}
+	
+	public static IEnumerable<Func<(UInt512, byte)>> ConvertToCheckedByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, byte)>> ConvertToSaturatingByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.MaxValue, byte.MaxValue);
+		yield return () => (UInt512.ByteMaxValue + UInt512.One, byte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, byte)>> ConvertToTruncatingByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.MaxValue, byte.MaxValue);
+		yield return () => (UInt512.ByteMaxValue + UInt512.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt512, ushort)>> ConvertToCheckedUInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, ushort)>> ConvertToSaturatingUInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue + UInt512.One, ushort.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, ushort)>> ConvertToTruncatingUInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue + UInt512.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt512, uint)>> ConvertToCheckedUInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, uint)>> ConvertToSaturatingUInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue + UInt512.One, uint.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, uint)>> ConvertToTruncatingUInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue + UInt512.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt512, ulong)>> ConvertToCheckedUInt64TestData()
+	{
+		yield return () => (UInt512.One, 1U);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, ulong)>> ConvertToSaturatingUInt64TestData()
+	{
+		yield return () => (UInt512.One, 1U);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue + UInt512.One, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, ulong)>> ConvertToTruncatingUInt64TestData()
+	{
+		yield return () => (UInt512.One, 1U);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue + UInt512.One, 0);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt128)>> ConvertToCheckedUInt128TestData()
+	{
+		yield return () => (UInt512.One, UInt128.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, UInt128)>> ConvertToSaturatingUInt128TestData()
+	{
+		yield return () => (UInt512.One, UInt128.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue + UInt512.One, UInt128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, UInt128)>> ConvertToTruncatingUInt128TestData()
+	{
+		yield return () => (UInt512.One, UInt128.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue + UInt512.One, UInt128.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, UInt256)>> ConvertToCheckedUInt256TestData()
+	{
+		yield return () => (UInt512.One, UInt256.One);
+		yield return () => (UInt512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (UInt512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, UInt256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, UInt256)>> ConvertToSaturatingUInt256TestData()
+	{
+		yield return () => (UInt512.One, UInt256.One);
+		yield return () => (UInt512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (UInt512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, UInt256.MaxValue);
+		yield return () => (UInt512.MaxValue, UInt256.MaxValue);
+		yield return () => (UInt512.UInt256MaxValue + UInt512.One, UInt256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, UInt256)>> ConvertToTruncatingUInt256TestData()
+	{
+		yield return () => (UInt512.One, UInt256.One);
+		yield return () => (UInt512.ByteMaxValue, UInt256.ByteMaxValue);
+		yield return () => (UInt512.UInt16MaxValue, UInt256.UInt16MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, UInt256.UInt32MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, UInt256.UInt64MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt256.UInt128MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, UInt256.MaxValue);
+		yield return () => (UInt512.MaxValue, UInt256.MaxValue);
+		yield return () => (UInt512.UInt256MaxValue + UInt512.One, UInt256.Zero);
+	}
+
+	public static IEnumerable<Func<(UInt512, sbyte)>> ConvertToCheckedSByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, sbyte)>> ConvertToSaturatingSByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.MaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue + UInt512.One, sbyte.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, sbyte)>> ConvertToTruncatingSByteTestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.MaxValue, unchecked((sbyte)0xFF));
+		yield return () => (UInt512.SByteMaxValue + UInt512.One, unchecked((sbyte)0x80));
+	}
+
+	public static IEnumerable<Func<(UInt512, short)>> ConvertToCheckedInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, short)>> ConvertToSaturatingInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int16MaxValue + UInt512.One, short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, short)>> ConvertToTruncatingInt16TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.MaxValue, unchecked((short)0xFFFF));
+		yield return () => (UInt512.Int16MaxValue + UInt512.One, unchecked((short)0x8000));
+	}
+
+	public static IEnumerable<Func<(UInt512, int)>> ConvertToCheckedInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, int)>> ConvertToSaturatingInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int32MaxValue + UInt512.One, int.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, int)>> ConvertToTruncatingInt32TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.MaxValue, unchecked((int)0xFFFF_FFFF));
+		yield return () => (UInt512.Int32MaxValue + UInt512.One, unchecked((int)0x8000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt512, long)>> ConvertToCheckedInt64TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, long)>> ConvertToSaturatingInt64TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.MaxValue, long.MaxValue);
+		yield return () => (UInt512.Int64MaxValue + UInt512.One, long.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, long)>> ConvertToTruncatingInt64TestData()
+	{
+		yield return () => (UInt512.One, 1);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.MaxValue, unchecked((long)0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt512.Int64MaxValue + UInt512.One, unchecked((long)0x8000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt512, Int128)>> ConvertToCheckedInt128TestData()
+	{
+		yield return () => (UInt512.One, Int128.One);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int128)>> ConvertToSaturatingInt128TestData()
+	{
+		yield return () => (UInt512.One, Int128.One);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (UInt512.MaxValue, Int128.MaxValue);
+		yield return () => (UInt512.Int128MaxValue + UInt512.One, Int128.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int128)>> ConvertToTruncatingInt128TestData()
+	{
+		yield return () => (UInt512.One, Int128.One);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int128.MaxValue);
+		yield return () => (UInt512.MaxValue, new Int128(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt512.Int128MaxValue + UInt512.One, new Int128(0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt512, Int256)>> ConvertToCheckedInt256TestData()
+	{
+		yield return () => (UInt512.One, Int256.One);
+		yield return () => (UInt512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int256)>> ConvertToSaturatingInt256TestData()
+	{
+		yield return () => (UInt512.One, Int256.One);
+		yield return () => (UInt512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int256.MaxValue);
+		yield return () => (UInt512.MaxValue, Int256.MaxValue);
+		yield return () => (UInt512.Int256MaxValue + UInt512.One, Int256.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int256)>> ConvertToTruncatingInt256TestData()
+	{
+		yield return () => (UInt512.One, Int256.One);
+		yield return () => (UInt512.SByteMaxValue, Int256.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int256.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int256.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int256.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int256.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int256.MaxValue);
+		yield return () => (UInt512.MaxValue, new Int256(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt512.Int256MaxValue + UInt512.One, new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+
+	public static IEnumerable<Func<(UInt512, Int512)>> ConvertToCheckedInt512TestData()
+	{
+		yield return () => (UInt512.One, Int512.One);
+		yield return () => (UInt512.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt512.Int512MaxValue, Int512.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int512)>> ConvertToSaturatingInt512TestData()
+	{
+		yield return () => (UInt512.One, Int512.One);
+		yield return () => (UInt512.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt512.Int512MaxValue, Int512.MaxValue);
+		yield return () => (UInt512.MaxValue, Int512.MaxValue);
+		yield return () => (UInt512.Int512MaxValue + UInt512.One, Int512.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Int512)>> ConvertToTruncatingInt512TestData()
+	{
+		yield return () => (UInt512.One, Int512.One);
+		yield return () => (UInt512.SByteMaxValue, Int512.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Int512.Int16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Int512.Int32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Int512.Int64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Int512.Int128MaxValue);
+		yield return () => (UInt512.Int256MaxValue, Int512.Int256MaxValue);
+		yield return () => (UInt512.Int512MaxValue, Int512.MaxValue);
+		yield return () => (UInt512.MaxValue, new Int512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF));
+		yield return () => (UInt512.Int512MaxValue + UInt512.One, new Int512(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+	}
+	
+	public static IEnumerable<Func<(UInt512, BigInteger)>> ConvertToCheckedBigIntegerTestData()
+	{
+		yield return () => (UInt512.One, BigInteger.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+		yield return () => (UInt512.MaxValue, BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
+	}
+
+	public static IEnumerable<Func<(UInt512, BigInteger)>> ConvertToSaturatingBigIntegerTestData()
+	{
+		yield return () => (UInt512.One, BigInteger.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+		yield return () => (UInt512.MaxValue, BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
+	}
+
+	public static IEnumerable<Func<(UInt512, BigInteger)>> ConvertToTruncatingBigIntegerTestData()
+	{
+		yield return () => (UInt512.One, BigInteger.One);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, UInt128.MaxValue);
+		yield return () => (UInt512.UInt256MaxValue, BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+		yield return () => (UInt512.MaxValue, BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"));
+	}
+
+	public static IEnumerable<Func<(UInt512, Half)>> ConvertToCheckedHalfTestData()
+	{
+		yield return () => (UInt512.One, Half.One);
+		yield return () => (UInt512.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, (Half)short.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Half)>> ConvertToSaturatingHalfTestData()
+	{
+		yield return () => (UInt512.One, Half.One);
+		yield return () => (UInt512.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Half.MaxValue);
+		yield return () => (UInt512.MaxValue, Half.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Half)>> ConvertToTruncatingHalfTestData()
+	{
+		yield return () => (UInt512.One, Half.One);
+		yield return () => (UInt512.ByteMaxValue, (Half)byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, (Half)sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, (Half)short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Half.MaxValue);
+		yield return () => (UInt512.MaxValue, Half.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, float)>> ConvertToCheckedSingleTestData()
+	{
+		yield return () => (UInt512.One, 1f);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, float)>> ConvertToSaturatingSingleTestData()
+	{
+		yield return () => (UInt512.One, 1f);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, float)>> ConvertToTruncatingSingleTestData()
+	{
+		yield return () => (UInt512.One, 1f);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, double)>> ConvertToCheckedDoubleTestData()
+	{
+		yield return () => (UInt512.One, 1d);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (UInt512.Parse("693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+	
+	public static IEnumerable<Func<(UInt512, double)>> ConvertToSaturatingDoubleTestData()
+	{
+		yield return () => (UInt512.One, 1d);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (UInt512.Parse("693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+	
+	public static IEnumerable<Func<(UInt512, double)>> ConvertToTruncatingDoubleTestData()
+	{
+		yield return () => (UInt512.One, 1d);
+		yield return () => (UInt512.ByteMaxValue, byte.MaxValue);
+		yield return () => (UInt512.SByteMaxValue, sbyte.MaxValue);
+		yield return () => (UInt512.Int16MaxValue, short.MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, ushort.MaxValue);
+		yield return () => (UInt512.Int32MaxValue, int.MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, uint.MaxValue);
+		yield return () => (UInt512.Int64MaxValue, long.MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, ulong.MaxValue);
+		yield return () => (UInt512.Int128MaxValue, (double)Int128.MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, (double)UInt128.MaxValue);
+		
+		yield return () => (UInt512.Parse("781377183594418599030564404241984000000000000000000"),
+			781377183594418599030564404241984000000000000000000.0d);
+		yield return () => (UInt512.Parse("693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455"),
+			693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455.0d);
+	}
+
+	public static IEnumerable<Func<(UInt512, Quad)>> ConvertToCheckedQuadTestData()
+	{
+		yield return () => (UInt512.One, Quad.One);
+		yield return () => (UInt512.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Quad)>> ConvertToSaturatingQuadTestData()
+	{
+		yield return () => (UInt512.One, Quad.One);
+		yield return () => (UInt512.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Quad)>> ConvertToTruncatingQuadTestData()
+	{
+		yield return () => (UInt512.One, Quad.One);
+		yield return () => (UInt512.ByteMaxValue, Quad.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Quad.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Quad.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Quad.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Quad.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Quad.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Quad.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Quad.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt512, Octo)>> ConvertToCheckedOctoTestData()
+	{
+		yield return () => (UInt512.One, Octo.One);
+		yield return () => (UInt512.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Octo)>> ConvertToSaturatingOctoTestData()
+	{
+		yield return () => (UInt512.One, Octo.One);
+		yield return () => (UInt512.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt512, Octo)>> ConvertToTruncatingOctoTestData()
+	{
+		yield return () => (UInt512.One, Octo.One);
+		yield return () => (UInt512.ByteMaxValue, Octo.ByteMaxValue);
+		yield return () => (UInt512.SByteMaxValue, Octo.SByteMaxValue);
+		yield return () => (UInt512.Int16MaxValue, Octo.Int16MaxValue);
+		yield return () => (UInt512.UInt16MaxValue, Octo.UInt16MaxValue);
+		yield return () => (UInt512.Int32MaxValue, Octo.Int32MaxValue);
+		yield return () => (UInt512.UInt32MaxValue, Octo.UInt32MaxValue);
+		yield return () => (UInt512.Int64MaxValue, Octo.Int64MaxValue);
+		yield return () => (UInt512.UInt64MaxValue, Octo.UInt64MaxValue);
+		yield return () => (UInt512.Int128MaxValue, Octo.Int128MaxValue);
+		yield return () => (UInt512.UInt128MaxValue, Octo.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(byte, UInt512)>> ConvertFromCheckedByteTestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, UInt512)>> ConvertFromSaturatingByteTestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(byte, UInt512)>> ConvertFromTruncatingByteTestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(ushort, UInt512)>> ConvertFromCheckedUInt16TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, UInt512)>> ConvertFromSaturatingUInt16TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ushort, UInt512)>> ConvertFromTruncatingUInt16TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(uint, UInt512)>> ConvertFromCheckedUInt32TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, UInt512)>> ConvertFromSaturatingUInt32TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(uint, UInt512)>> ConvertFromTruncatingUInt32TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+
+	public static IEnumerable<Func<(ulong, UInt512)>> ConvertFromCheckedUInt64TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, UInt512)>> ConvertFromSaturatingUInt64TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(ulong, UInt512)>> ConvertFromTruncatingUInt64TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+	}
+
+	public static IEnumerable<Func<(UInt128, UInt512)>> ConvertFromCheckedUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt512.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, UInt512)>> ConvertFromSaturatingUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt512.UInt128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(UInt128, UInt512)>> ConvertFromTruncatingUInt128TestData()
+	{
+		yield return () => (UInt128.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => (ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => (UInt128.MaxValue, UInt512.UInt128MaxValue);
+	}
+
+	public static IEnumerable<Func<(sbyte, UInt512)>> ConvertFromCheckedSByteTestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, UInt512)>> ConvertFromSaturatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, UInt512.Zero);
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(sbyte, UInt512)>> ConvertFromTruncatingSByteTestData()
+	{
+		yield return () => (sbyte.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(short, UInt512)>> ConvertFromCheckedInt16TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, UInt512)>> ConvertFromSaturatingInt16TestData()
+	{
+		yield return () => (short.MinValue, UInt512.Zero);
+		yield return () => (sbyte.MinValue, UInt512.Zero);
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(short, UInt512)>> ConvertFromTruncatingInt16TestData()
+	{
+		yield return () => (short.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+	}
+
+	public static IEnumerable<Func<(int, UInt512)>> ConvertFromCheckedInt32TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, UInt512)>> ConvertFromSaturatingInt32TestData()
+	{
+		yield return () => (int.MinValue, UInt512.Zero);
+		yield return () => (short.MinValue, UInt512.Zero);
+		yield return () => (sbyte.MinValue, UInt512.Zero);
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(int, UInt512)>> ConvertFromTruncatingInt32TestData()
+	{
+		yield return () => (int.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+	}
+
+	public static IEnumerable<Func<(long, UInt512)>> ConvertFromCheckedInt64TestData()
+	{
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, UInt512)>> ConvertFromSaturatingInt64TestData()
+	{
+		yield return () => (long.MinValue, UInt512.Zero);
+		yield return () => (int.MinValue, UInt512.Zero);
+		yield return () => (short.MinValue, UInt512.Zero);
+		yield return () => (sbyte.MinValue, UInt512.Zero);
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+	}
+	
+	public static IEnumerable<Func<(long, UInt512)>> ConvertFromTruncatingInt64TestData()
+	{
+		yield return () => (long.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
+		yield return () => (int.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (1, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+	}
+
+	public static IEnumerable<Func<(Int128, UInt512)>> ConvertFromCheckedInt128TestData()
+	{
+		yield return () => (Int128.One, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, UInt512)>> ConvertFromSaturatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, UInt512.Zero);
+		yield return () => (long.MinValue, UInt512.Zero);
+		yield return () => (int.MinValue, UInt512.Zero);
+		yield return () => (short.MinValue, UInt512.Zero);
+		yield return () => (sbyte.MinValue, UInt512.Zero);
+		yield return () => (Int128.One, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(Int128, UInt512)>> ConvertFromTruncatingInt128TestData()
+	{
+		yield return () => (Int128.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000));
+		yield return () => (long.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000));
+		yield return () => (int.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000));
+		yield return () => (short.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000));
+		yield return () => (sbyte.MinValue, new UInt512(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80));
+		yield return () => (Int128.One, UInt512.One);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => (Int128.MaxValue, UInt512.Int128MaxValue);
+	}
+	
+	public static IEnumerable<Func<(BigInteger, UInt512)>> ConvertFromCheckedBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt512.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt512.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt512.UInt256MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"), UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, UInt512)>> ConvertFromSaturatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt512.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt512.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt512.UInt256MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"), UInt512.MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"), UInt512.MaxValue);
+	}
+
+	public static IEnumerable<Func<(BigInteger, UInt512)>> ConvertFromTruncatingBigIntegerTestData()
+	{
+		yield return () => (BigInteger.One, UInt512.One);
+		yield return () => ((BigInteger)byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => ((BigInteger)sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => ((BigInteger)short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => ((BigInteger)ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => ((BigInteger)int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => ((BigInteger)uint.MaxValue, UInt512.UInt32MaxValue);
+		yield return () => ((BigInteger)long.MaxValue, UInt512.Int64MaxValue);
+		yield return () => ((BigInteger)ulong.MaxValue, UInt512.UInt64MaxValue);
+		yield return () => ((BigInteger)Int128.MaxValue, UInt512.Int128MaxValue);
+		yield return () => ((BigInteger)UInt128.MaxValue, UInt512.UInt128MaxValue);
+		yield return () => (BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639935"), UInt512.UInt256MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095"), UInt512.MaxValue);
+		yield return () => (BigInteger.Parse("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"), UInt512.Zero);
+	}
+
+	public static IEnumerable<Func<(Half, UInt512)>> ConvertFromCheckedHalfTestData()
+	{
+		yield return () => (Half.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, UInt512)>> ConvertFromSaturatingHalfTestData()
+	{
+		yield return () => (Half.MinValue, UInt512.Zero);
+		yield return () => (Half.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+	
+	public static IEnumerable<Func<(Half, UInt512)>> ConvertFromTruncatingHalfTestData()
+	{
+		yield return () => (Half.MinValue, UInt512.Zero);
+		yield return () => (Half.One, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+	}
+
+	public static IEnumerable<Func<(float, UInt512)>> ConvertFromCheckedSingleTestData()
+	{
+		yield return () => (1f, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, UInt512)>> ConvertFromSaturatingSingleTestData()
+	{
+		yield return () => (float.MinValue, UInt512.Zero);
+		yield return () => (1f, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+	
+	public static IEnumerable<Func<(float, UInt512)>> ConvertFromTruncatingSingleTestData()
+	{
+		yield return () => (float.MinValue, UInt512.Zero);
+		yield return () => (1f, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+	}
+
+	public static IEnumerable<Func<(double, UInt512)>> ConvertFromCheckedDoubleTestData()
+	{
+		yield return () => (1d, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, UInt512)>> ConvertFromSaturatingDoubleTestData()
+	{
+		yield return () => (double.MinValue, UInt512.Zero);
+		yield return () => (1d, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+	
+	public static IEnumerable<Func<(double, UInt512)>> ConvertFromTruncatingDoubleTestData()
+	{
+		yield return () => (double.MinValue, UInt512.Zero);
+		yield return () => (1d, UInt512.One);
+		yield return () => (byte.MaxValue, UInt512.ByteMaxValue);
+		yield return () => (sbyte.MaxValue, UInt512.SByteMaxValue);
+		yield return () => (short.MaxValue, UInt512.Int16MaxValue);
+		yield return () => (ushort.MaxValue, UInt512.UInt16MaxValue);
+		yield return () => (int.MaxValue, UInt512.Int32MaxValue);
+		yield return () => (uint.MaxValue, UInt512.UInt32MaxValue);
+	}
+}
diff --git a/src/MissingValues.Tests/Extensions/Int256Extensions.cs b/src/MissingValues.Tests/Extensions/Int256Extensions.cs
new file mode 100644
index 0000000..b184528
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/Int256Extensions.cs
@@ -0,0 +1,37 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class Int256Extensions
+{
+	extension(Int256)
+	{
+		public static Int256 SByteMaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_007F);
+		public static Int256 SByteMinValue => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80);
+
+		public static Int256 ByteMaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
+
+		public static Int256 Int16MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF);
+		public static Int256 Int16MinValue => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000);
+
+		public static Int256 UInt16MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF);
+
+		public static Int256 Int32MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF);
+		public static Int256 Int32MinValue => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000);
+
+		public static Int256 UInt32MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF);
+
+		public static Int256 Int64MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF);
+		public static Int256 Int64MinValue => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000);
+
+		public static Int256 UInt64MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Int256 Int128MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static Int256 Int128MinValue => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Int256 UInt128MaxValue => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Int256 NegativeTwo => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static Int256 Two => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
+		public static Int256 MaxValueMinusOne => new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static Int256 MinValuePlusOne => new(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/Int512Extensions.cs b/src/MissingValues.Tests/Extensions/Int512Extensions.cs
new file mode 100644
index 0000000..0ef2cc5
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/Int512Extensions.cs
@@ -0,0 +1,86 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class Int512Extensions
+{
+	extension(Int512)
+	{
+		public static Int512 SByteMaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_007F);
+		public static Int512 SByteMinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FF80);
+
+		public static Int512 ByteMaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
+
+		public static Int512 Int16MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF);
+		public static Int512 Int16MinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_8000);
+
+		public static Int512 UInt16MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF);
+
+		public static Int512 Int32MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF);
+		public static Int512 Int32MinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_8000_0000);
+
+		public static Int512 UInt32MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF);
+
+		public static Int512 Int64MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF);
+		public static Int512 Int64MinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000);
+
+		public static Int512 UInt64MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Int512 Int128MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static Int512 Int128MinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0x8000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Int512 UInt128MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Int512 Int256MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static Int512 Int256MinValue => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Int512 UInt256MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Int512 NegativeTwo => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static Int512 Two => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
+		public static Int512 MaxValueMinusOne => new(
+			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static Int512 MinValuePlusOne => new(
+			0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000,
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/NumberBaseAssertionExtensions.cs b/src/MissingValues.Tests/Extensions/NumberBaseAssertionExtensions.cs
new file mode 100644
index 0000000..f0ffe7c
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/NumberBaseAssertionExtensions.cs
@@ -0,0 +1,93 @@
+using System.ComponentModel;
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using TUnit.Assertions.Attributes;
+using TUnit.Assertions.Core;
+
+namespace MissingValues.Tests.Extensions;
+
+public static class NumberBaseAssertionExtensions
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be bitwise equivalent to {other}")]
+	public static bool IsBitwiseEquivalentTo<T1>(this T1 value, T1 other)
+		where T1 : struct, IFloatingPointIeee754<T1>
+	{
+		switch (Unsafe.SizeOf<T1>())
+		{
+			case 16:
+				return Unsafe.BitCast<T1, UInt128>(value) == Unsafe.BitCast<T1, UInt128>(other);
+			case UInt256.Size:
+				return Unsafe.BitCast<T1, UInt256>(value) == Unsafe.BitCast<T1, UInt256>(other);
+			default:
+				return false;
+		}
+	}
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be approximately equal to {precision}")]
+	public static AssertionResult IsApproximately<T>(this T value, T expected, T precision)
+		where T : IFloatingPointIeee754<T>
+	{
+		if (T.IsNaN(value))
+		{
+			return AssertionResult.Failed($"Cannot determine approximation of a {typeof(T)} to NaN");
+		}
+		if (T.IsNegative(precision))
+		{
+			return AssertionResult.Failed($"Cannot determine precision of a {typeof(T)} if its negative");
+		}
+		if (T.IsInfinity(value))
+		{
+			return AssertionResult.Failed($"Cannot determine approximation of a {typeof(T)} to Infinity");
+		}
+		
+		T actualDifference = T.Abs(expected - value);
+
+		if (actualDifference <= precision)
+		{
+			return AssertionResult.Passed;
+		}
+		
+		return AssertionResult.Failed($"Expected {value} to approximate {expected} +/- {precision}, but {value} differed by {actualDifference}.");
+	}
+	
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Not a Number")]
+	public static bool IsNaN(this Quad value)
+	{
+		return Quad.IsNaN(value);
+	}
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Not a Number")]
+	public static bool IsNaN(this Octo value)
+	{
+		return Octo.IsNaN(value);
+	}
+	
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Negative Infinity")]
+	public static bool IsNegativeInfinity(this Quad value)
+	{
+		return Quad.IsNegativeInfinity(value);
+	}
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Negative Infinity")]
+	public static bool IsNegativeInfinity(this Octo value)
+	{
+		return Octo.IsNegativeInfinity(value);
+	}
+	
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Negative Infinity")]
+	public static bool IsPositiveInfinity(this Quad value)
+	{
+		return Quad.IsPositiveInfinity(value);
+	}
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	[GenerateAssertion(ExpectationMessage = "to be Negative Infinity")]
+	public static bool IsPositiveInfinity(this Octo value)
+	{
+		return Octo.IsPositiveInfinity(value);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/OctoExtensions.cs b/src/MissingValues.Tests/Extensions/OctoExtensions.cs
new file mode 100644
index 0000000..a87a100
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/OctoExtensions.cs
@@ -0,0 +1,53 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class OctoExtensions
+{
+	extension(Octo)
+	{
+		public static Octo NegativeThousand => Values.CreateFloat<Octo>(0xC000_8F40_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeHundred => Values.CreateFloat<Octo>(0xC000_5900_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeTen => Values.CreateFloat<Octo>(0xC000_2400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeFive => Values.CreateFloat<Octo>(0xC000_1400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeFour => Values.CreateFloat<Octo>(0xC000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeThree => Values.CreateFloat<Octo>(0xC000_0800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeTwo => Values.CreateFloat<Octo>(0xC000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeHalf => Values.CreateFloat<Octo>(0xBFFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo NegativeQuarter => Values.CreateFloat<Octo>(0xBFFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Quarter => Values.CreateFloat<Octo>(0x3FFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Half => Values.CreateFloat<Octo>(0x3FFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Two => Values.CreateFloat<Octo>(0x4000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Three => Values.CreateFloat<Octo>(0x4000_0800_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Four => Values.CreateFloat<Octo>(0x4000_1000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Five => Values.CreateFloat<Octo>(0x4000_1400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Ten => Values.CreateFloat<Octo>(0x4000_2400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Hundred => Values.CreateFloat<Octo>(0x4000_5900_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Thousand => Values.CreateFloat<Octo>(0x4000_8F40_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Octo GreaterThanOneSmallest => Values.CreateFloat<Octo>(0x3FFF_F000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+		public static Octo LessThanOneLargest => Values.CreateFloat<Octo>(0x3FFF_EFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Octo SmallestSubnormal => Values.CreateFloat<Octo>(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+		public static Octo GreatestSubnormal => Values.CreateFloat<Octo>(0x0000_0FFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Octo ByteMaxValue => Values.CreateFloat<Octo>(0x4000_6FE0_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo UInt16MaxValue => Values.CreateFloat<Octo>(0x4000_EFFF_E000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo UInt32MaxValue => Values.CreateFloat<Octo>(0x4001_EFFF_FFFF_E000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo UInt64MaxValue => Values.CreateFloat<Octo>(0x4003_EFFF_FFFF_FFFF, 0xFFFF_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo UInt128MaxValue => Values.CreateFloat<Octo>(0x4007_EFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_E000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo TwoOver255 => Values.CreateFloat<Octo>(0x400F_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo TwoOver511 => Values.CreateFloat<Octo>(0x401F_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Octo SByteMaxValue => Values.CreateFloat<Octo>(0x4000_5FC0_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo SByteMinValue => Values.CreateFloat<Octo>(0xC000_6000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int16MaxValue => Values.CreateFloat<Octo>(0x4000_DFFF_C000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int16MinValue => Values.CreateFloat<Octo>(0xC000_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int32MaxValue => Values.CreateFloat<Octo>(0x4001_DFFF_FFFF_C000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int32MinValue => Values.CreateFloat<Octo>(0xC001_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int64MaxValue => Values.CreateFloat<Octo>(0x4003_DFFF_FFFF_FFFF, 0xFFFF_C000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int64MinValue => Values.CreateFloat<Octo>(0xC003_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int128MaxValue => Values.CreateFloat<Octo>(0x4007_DFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_C000_0000_0000, 0x0000_0000_0000_0000);
+		public static Octo Int128MinValue => Values.CreateFloat<Octo>(0xC007_E000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Octo Delta => Values.CreateFloat<Octo>(0x400E_B000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/QuadExtensions.cs b/src/MissingValues.Tests/Extensions/QuadExtensions.cs
new file mode 100644
index 0000000..d54a029
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/QuadExtensions.cs
@@ -0,0 +1,63 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class QuadExtensions
+{
+	extension(Quad)
+	{
+		public static Quad NegativeThousand => Values.CreateFloat<Quad>(0xC008_F400_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeHundred => Values.CreateFloat<Quad>(0xC005_9000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeTen => Values.CreateFloat<Quad>(0xC002_4000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeSix => Values.CreateFloat<Quad>(0xC001_8000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeFive => Values.CreateFloat<Quad>(0xC001_4000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeFour => Values.CreateFloat<Quad>(0xC001_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeThree => Values.CreateFloat<Quad>(0xC000_8000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeTwo => Values.CreateFloat<Quad>(0xC000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeHalf => Values.CreateFloat<Quad>(0xBFFE_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad NegativeQuarter => Values.CreateFloat<Quad>(0xBFFD_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Quarter => Values.CreateFloat<Quad>(0x3FFD_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Half => Values.CreateFloat<Quad>(0x3FFE_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Two => Values.CreateFloat<Quad>(0x4000_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Three => Values.CreateFloat<Quad>(0x4000_8000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Four => Values.CreateFloat<Quad>(0x4001_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Five => Values.CreateFloat<Quad>(0x4001_4000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Six => Values.CreateFloat<Quad>(0x4001_8000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Ten => Values.CreateFloat<Quad>(0x4002_4000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Hundred => Values.CreateFloat<Quad>(0x4005_9000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Thousand => Values.CreateFloat<Quad>(0x4008_F400_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Quad GreaterThanOneSmallest => Values.CreateFloat<Quad>(0x3FFF_0000_0000_0000, 0x0000_0000_0000_0001);
+		public static Quad LessThanOneLargest => Values.CreateFloat<Quad>(0x3FFE_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Quad SmallestSubnormal => Values.CreateFloat<Quad>(0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+		public static Quad GreatestSubnormal => Values.CreateFloat<Quad>(0x0000_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static Quad ByteMaxValue => Values.CreateFloat<Quad>(0x4006_FE00_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad UInt16MaxValue => Values.CreateFloat<Quad>(0x400E_FFFE_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad UInt32MaxValue => Values.CreateFloat<Quad>(0x401E_FFFF_FFFE_0000, 0x0000_0000_0000_0000);
+		public static Quad UInt64MaxValue => Values.CreateFloat<Quad>(0x403E_FFFF_FFFF_FFFF, 0xFFFE_0000_0000_0000);
+		public static Quad TwoOver128 => Values.CreateFloat<Quad>(0x407F_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad TwoOver256 => Values.CreateFloat<Quad>(0x40FF_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad TwoOver512 => Values.CreateFloat<Quad>(0x41FF_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad TwoOver127 => Values.CreateFloat<Quad>(0x407E_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad TwoOver255 => Values.CreateFloat<Quad>(0x40FE_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad TwoOver511 => Values.CreateFloat<Quad>(0x41FE_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Quad SByteMaxValue => Values.CreateFloat<Quad>(0x4005_FC00_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad SByteMinValue => Values.CreateFloat<Quad>(0xC006_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Int16MaxValue => Values.CreateFloat<Quad>(0x400D_FFFC_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Int16MinValue => Values.CreateFloat<Quad>(0xC00E_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Int32MaxValue => Values.CreateFloat<Quad>(0x401D_FFFF_FFFC_0000, 0x0000_0000_0000_0000);
+		public static Quad Int32MinValue => Values.CreateFloat<Quad>(0xC01E_0000_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad Int64MaxValue => Values.CreateFloat<Quad>(0x403D_FFFF_FFFF_FFFF, 0xFFFC_0000_0000_0000);
+		public static Quad Int64MinValue => Values.CreateFloat<Quad>(0xC03E_0000_0000_0000, 0x0000_0000_0000_0000);
+
+		public static Quad HalfMaxValue => Values.CreateFloat<Quad>(0x400E_FFC0_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad HalfMinValue => Values.CreateFloat<Quad>(0xC00E_FFC0_0000_0000, 0x0000_0000_0000_0000);
+		public static Quad SingleMaxValue => Values.CreateFloat<Quad>(0x407E_FFFF_FE00_0000, 0x0000_0000_0000_0000);
+		public static Quad SingleMinValue => Values.CreateFloat<Quad>(0xC07E_FFFF_FE00_0000, 0x0000_0000_0000_0000);
+		public static Quad DoubleMaxValue => Values.CreateFloat<Quad>(0x43FE_FFFF_FFFF_FFFF, 0xF000_0000_0000_0000);
+		public static Quad DoubleMinValue => Values.CreateFloat<Quad>(0xC3FE_FFFF_FFFF_FFFF, 0xF000_0000_0000_0000);
+
+		public static Quad Delta => Values.CreateFloat<Quad>(0x406F_0000_0000_0000, 0x0000_0000_0000_0000);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/UInt256Extensions.cs b/src/MissingValues.Tests/Extensions/UInt256Extensions.cs
new file mode 100644
index 0000000..8e06c63
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/UInt256Extensions.cs
@@ -0,0 +1,24 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class UInt256Extensions
+{
+	extension(UInt256)
+	{
+		public static UInt256 SByteMaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_0000_007F);
+		public static UInt256 ByteMaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
+		public static UInt256 Int16MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF);
+		public static UInt256 UInt16MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF);
+		public static UInt256 Int32MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF);
+		public static UInt256 UInt32MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF);
+		public static UInt256 UInt64MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt256 Int64MaxValue => new(0, 0, 0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF);
+		public static UInt256 Int128MaxValue => new(0, 0, 0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt256 UInt128MaxValue => new(0, 0, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt256 Int256MaxValue => new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static UInt256 Two => new(0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
+		public static UInt256 MaxValueMinusOne => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static UInt256 MaxValueMinusTwo => new(0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFD);
+		public static UInt256 HalfMaxValue => new(0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Extensions/UInt512Extensions.cs b/src/MissingValues.Tests/Extensions/UInt512Extensions.cs
new file mode 100644
index 0000000..07c88f3
--- /dev/null
+++ b/src/MissingValues.Tests/Extensions/UInt512Extensions.cs
@@ -0,0 +1,60 @@
+namespace MissingValues.Tests.Extensions;
+
+public static class UInt512Extensions
+{
+	extension(UInt512)
+	{
+		public static UInt512 SByteMaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_007F);
+		public static UInt512 ByteMaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_00FF);
+		public static UInt512 Int16MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0x0000_0000_0000_7FFF);
+		public static UInt512 UInt16MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0x0000_0000_0000_FFFF);
+		public static UInt512 Int32MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0x0000_0000_7FFF_FFFF);
+		public static UInt512 UInt32MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0x0000_0000_FFFF_FFFF);
+		public static UInt512 Int64MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF);
+		public static UInt512 UInt64MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x0000_0000_0000_0000, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt512 Int128MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt512 UInt128MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt512 Int256MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt512 UInt256MaxValue => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+		public static UInt512 Int512MaxValue => new(
+			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+
+		public static UInt512 Two => new(
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 
+			0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
+		public static UInt512 MaxValueMinusOne => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFE);
+		public static UInt512 MaxValueMinusTwo => new(
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF,  0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFD);
+		public static UInt512 HalfMaxValue => new(
+			0x7FFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 
+			0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF);
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/GlobalSetup.cs b/src/MissingValues.Tests/GlobalSetup.cs
new file mode 100644
index 0000000..07c194b
--- /dev/null
+++ b/src/MissingValues.Tests/GlobalSetup.cs
@@ -0,0 +1,22 @@
+// Here you could define global logic that would affect all tests
+
+// You can use attributes at the assembly level to apply to all tests in the assembly
+[assembly: Retry(3)]
+[assembly: System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+
+namespace MissingValues.Tests;
+
+public class GlobalHooks
+{
+	[Before(TestSession)]
+	public static void SetUp()
+	{
+		Console.WriteLine(@"Or you can define methods that do stuff before...");
+	}
+
+	[After(TestSession)]
+	public static void CleanUp()
+	{
+		Console.WriteLine(@"...and after!");
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Helper.cs b/src/MissingValues.Tests/Helper.cs
new file mode 100644
index 0000000..26677f0
--- /dev/null
+++ b/src/MissingValues.Tests/Helper.cs
@@ -0,0 +1,299 @@
+using System.Globalization;
+using System.Numerics;
+
+namespace MissingValues.Tests;
+
+public static class Helper
+{
+    public static NumberFormatInfo CustomInfo => new()
+    {
+        PositiveSign = "+",
+        NegativeSign = "-",
+        CurrencyPositivePattern = 0,
+        CurrencyNegativePattern = 2,
+        CurrencySymbol = "$",
+        CurrencyDecimalDigits = 2,
+        CurrencyDecimalSeparator = ".",
+        CurrencyGroupSeparator = ",",
+        CurrencyGroupSizes = [3],
+        NumberGroupSeparator = "_",
+        NumberGroupSizes = [2],
+        NumberDecimalDigits = 5,
+        NumberDecimalSeparator = ".",
+        NumberNegativePattern = 1,
+        PositiveInfinitySymbol = "+Inf",
+        NegativeInfinitySymbol = "-Inf",
+        NaNSymbol = "NaN",
+    };
+    
+    public static TSelf Abs<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.Abs(value);
+    }
+    public static bool IsCanonical<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsCanonical(value);
+    }
+    public static bool IsComplexNumber<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsComplexNumber(value);
+    }
+    public static bool IsEvenInteger<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsEvenInteger(value);
+    }
+    public static bool IsFinite<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsFinite(value);
+    }
+    public static bool IsImaginaryNumber<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsImaginaryNumber(value);
+    }
+    public static bool IsInfinity<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsInfinity(value);
+    }
+    public static bool IsInteger<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsInteger(value);
+    }
+    public static bool IsNaN<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsNaN(value);
+    }
+    public static bool IsNegative<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsNegative(value);
+    }
+    public static bool IsNegativeInfinity<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsNegativeInfinity(value);
+    }
+    public static bool IsNormal<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsNormal(value);
+    }
+    public static bool IsOddInteger<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsOddInteger(value);
+    }
+    public static bool IsPositive<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsPositive(value);
+    }
+    public static bool IsPositiveInfinity<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsPositiveInfinity(value);
+    }
+    public static bool IsRealNumber<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsRealNumber(value);
+    }
+    public static bool IsSubnormal<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsSubnormal(value);
+    }
+    public static bool IsZero<TSelf>(TSelf value)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.IsZero(value);
+    }
+    public static TSelf MaxMagnitude<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.MaxMagnitude(x, y);
+    }
+    public static TSelf MaxMagnitudeNumber<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.MaxMagnitudeNumber(x, y);
+    }
+    public static TSelf MinMagnitude<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.MinMagnitude(x, y);
+    }
+    public static TSelf MinMagnitudeNumber<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.MinMagnitudeNumber(x, y);
+    }
+    public static TSelf MultiplyAddEstimate<TSelf>(TSelf left, TSelf right, TSelf addend)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.MultiplyAddEstimate(left, right, addend);
+    }
+    public static TSelf Parse<TSelf>(string s, NumberStyles style, IFormatProvider? provider)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.Parse(s, style, provider);
+    }
+    public static TSelf Parse<TSelf>(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.Parse(s, style, provider);
+    }
+    public static TSelf Parse<TSelf>(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFormatProvider? provider)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.Parse(utf8Text, style, provider);
+    }
+    public static bool TryParse<TSelf>(string s, NumberStyles style, IFormatProvider? provider, out TSelf result)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.TryParse(s, style, provider, out result);
+    }
+    public static bool TryParse<TSelf>(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.TryParse(s, style, provider, out result);
+    }
+    public static bool TryParse<TSelf>(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFormatProvider? provider, out TSelf result)
+        where TSelf : INumberBase<TSelf>
+    {
+        return TSelf.TryParse(utf8Text, style, provider, out result);
+    }
+    public static TSelf Clamp<TSelf>(TSelf value, TSelf min, TSelf max)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.Clamp(value, min, max);
+    }
+    public static TSelf CopySign<TSelf>(TSelf value, TSelf sign)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.CopySign(value, sign);
+    }
+    public static TSelf Max<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.Max(x, y);
+    }
+    public static TSelf MaxNumber<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.MaxNumber(x, y);
+    }
+    public static TSelf Min<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.Min(x, y);
+    }
+    public static TSelf MinNumber<TSelf>(TSelf x, TSelf y)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.MinNumber(x, y);
+    }
+    public static int Sign<TSelf>(TSelf value)
+        where TSelf : INumber<TSelf>
+    {
+        return TSelf.Sign(value);
+    }
+    public static bool IsPow2<TSelf>(TSelf value)
+        where TSelf : IBinaryNumber<TSelf>
+    {
+        return TSelf.IsPow2(value);
+    }
+    public static TSelf Log2<TSelf>(TSelf value)
+        where TSelf : IBinaryNumber<TSelf>
+    {
+        return TSelf.Log2(value);
+    }
+    public static (TSelf Quotient, TSelf Remainder) DivRem<TSelf>(TSelf left, TSelf right)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.DivRem(left, right);
+    }
+    public static TSelf LeadingZeroCount<TSelf>(TSelf value)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.LeadingZeroCount(value);
+    }
+    public static TSelf PopCount<TSelf>(TSelf value)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.PopCount(value);
+    }
+    public static TSelf ReadBigEndian<TSelf>(ReadOnlySpan<byte> source, bool isUnsigned)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.ReadBigEndian(source, isUnsigned);
+    }
+    public static TSelf ReadLittleEndian<TSelf>(ReadOnlySpan<byte> source, bool isUnsigned)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.ReadLittleEndian(source, isUnsigned);
+    }
+    public static TSelf RotateLeft<TSelf>(TSelf value, int rotateAmount)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.RotateLeft(value, rotateAmount);
+    }
+    public static TSelf RotateRight<TSelf>(TSelf value, int rotateAmount)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.RotateRight(value, rotateAmount);
+    }
+    public static TSelf TrailingZeroCount<TSelf>(TSelf value)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return TSelf.TrailingZeroCount(value);
+    }
+    public static int GetByteCount<TSelf>(TSelf value)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return value.GetByteCount();
+    }
+    public static int GetShortestBitLength<TSelf>(TSelf value)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return value.GetShortestBitLength();
+    }
+    public static int WriteBigEndian<TSelf>(TSelf value, Span<byte> destination)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return value.WriteBigEndian(destination);
+    }
+    public static int WriteLittleEndian<TSelf>(TSelf value, Span<byte> destination)
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        return value.WriteLittleEndian(destination);
+    }
+    public static TSelf OnesComplement<TSelf>(TSelf value)
+        where TSelf : IBitwiseOperators<TSelf, TSelf, TSelf>
+    {
+        return ~value;
+    }
+    public static TSelf And<TSelf>(TSelf left, TSelf right)
+        where TSelf : IBitwiseOperators<TSelf, TSelf, TSelf>
+    {
+        return left & right;
+    }
+    public static TSelf Or<TSelf>(TSelf left, TSelf right)
+        where TSelf : IBitwiseOperators<TSelf, TSelf, TSelf>
+    {
+        return left | right;
+    }
+    public static TSelf Xor<TSelf>(TSelf left, TSelf right)
+        where TSelf : IBitwiseOperators<TSelf, TSelf, TSelf>
+    {
+        return left ^ right;
+    }
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Helpers/BinaryIntegerHelper.cs b/src/MissingValues.Tests/Helpers/BinaryIntegerHelper.cs
deleted file mode 100644
index 5bd3a0c..0000000
--- a/src/MissingValues.Tests/Helpers/BinaryIntegerHelper.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class BinaryIntegerHelper<TSelf>
-		where TSelf : IBinaryInteger<TSelf>
-	{
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.DivRem(TSelf, TSelf)"/>
-		public static (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right)
-		{
-			return TSelf.DivRem(left, right);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.LeadingZeroCount(TSelf)"/>
-		public static TSelf LeadingZeroCount(TSelf value)
-		{
-			return TSelf.LeadingZeroCount(value);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.PopCount(TSelf)"/>
-		public static TSelf PopCount(TSelf value)
-		{
-			return TSelf.PopCount(value);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.RotateLeft(TSelf, int)"/>
-		public static TSelf RotateLeft(TSelf value, int rotateAmount)
-		{
-			return TSelf.RotateLeft(value, rotateAmount);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.RotateRight(TSelf, int)"/>
-		public static TSelf RotateRight(TSelf value, int rotateAmount)
-		{
-			return TSelf.RotateRight(value, rotateAmount);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.TrailingZeroCount(TSelf)"/>
-		public static TSelf TrailingZeroCount(TSelf value)
-		{
-			return TSelf.TrailingZeroCount(value);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.TryReadBigEndian(ReadOnlySpan{byte}, bool, out TSelf)"/>
-		public static bool TryReadBigEndian(ReadOnlySpan<byte> source, bool isUnsigned, out TSelf value)
-		{
-			return TSelf.TryReadBigEndian(source, isUnsigned, out value);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.TryReadLittleEndian(ReadOnlySpan{byte}, bool, out TSelf)"/>
-		public static bool TryReadLittleEndian(ReadOnlySpan<byte> source, bool isUnsigned, out TSelf value)
-		{
-			return TSelf.TryReadLittleEndian(source, isUnsigned, out value);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.GetByteCount"/>
-		public static int GetByteCount(TSelf value)
-		{
-			return value.GetByteCount();
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.GetShortestBitLength"/>
-		public static int GetShortestBitLength(TSelf value)
-		{
-			return value.GetShortestBitLength();
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)"/>
-		public static bool TryWriteBigEndian(TSelf value, Span<byte> destination, out int bytesWritten)
-		{
-			return value.TryWriteBigEndian(destination, out bytesWritten);
-		}
-		/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)"/>
-		public static bool TryWriteLittleEndian(TSelf value, Span<byte> destination, out int bytesWritten)
-		{
-			return value.TryWriteLittleEndian(destination, out bytesWritten);
-		}
-
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/BinaryNumberHelper.cs b/src/MissingValues.Tests/Helpers/BinaryNumberHelper.cs
deleted file mode 100644
index b182c62..0000000
--- a/src/MissingValues.Tests/Helpers/BinaryNumberHelper.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class BinaryNumberHelper<TSelf>
-		where TSelf : IBinaryNumber<TSelf>
-	{
-		/// <inheritdoc cref="IBinaryNumber{TSelf}.AllBitsSet"/>
-		public static TSelf AllBitsSet => TSelf.AllBitsSet;
-		/// <inheritdoc cref="IBinaryNumber{TSelf}.IsPow2(TSelf)"/>
-		public static bool IsPow2(TSelf value) => TSelf.IsPow2(value);
-		/// <inheritdoc cref="IBinaryNumber{TSelf}.Log2(TSelf)"/>
-		public static TSelf Log2(TSelf value) => TSelf.Log2(value);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/FloatingPoint.cs b/src/MissingValues.Tests/Helpers/FloatingPoint.cs
deleted file mode 100644
index 14ec260..0000000
--- a/src/MissingValues.Tests/Helpers/FloatingPoint.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class FloatingPoint<TSelf>
-		where TSelf : IFloatingPoint<TSelf>
-	{
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/>
-		public static TSelf Ceiling(TSelf x) => TSelf.Ceiling(x);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Floor(TSelf)"/>
-		public static TSelf Floor(TSelf x) => TSelf.Floor(x);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf)"/>
-		public static TSelf Round(TSelf x) => TSelf.Round(x);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, int)"/>
-		public static TSelf Round(TSelf x, int digits) => TSelf.Round(x, digits);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, MidpointRounding)"/>
-		public static TSelf Round(TSelf x, MidpointRounding mode) => TSelf.Round(x, mode);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/>
-		public static TSelf Round(TSelf x, int digits, MidpointRounding mode) => TSelf.Round(x, digits, mode);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/>
-		public static TSelf Truncate(TSelf x) => TSelf.Truncate(x);
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()"/>
-		public static int GetExponentByteCount(TSelf x) => x.GetExponentByteCount();
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentShortestBitLength"/>
-		public static int GetExponentShortestBitLength(TSelf x) => x.GetExponentShortestBitLength();
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength"/>
-		public static int GetSignificandBitLength(TSelf x) => x.GetSignificandBitLength();
-		/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount"/>
-		public static int GetSignificandByteCount(TSelf x) => x.GetSignificandByteCount();
-		public static bool TryWriteExponentBigEndian(TSelf x, Span<byte> destination, out int bytesWritten) => x.TryWriteExponentBigEndian(destination, out bytesWritten);
-		public static bool TryWriteExponentLittleEndian(TSelf x, Span<byte> destination, out int bytesWritten) => x.TryWriteExponentLittleEndian(destination, out bytesWritten);
-		public static bool TryWriteSignificandBigEndian(TSelf x, Span<byte> destination, out int bytesWritten) => x.TryWriteSignificandBigEndian(destination, out bytesWritten);
-		public static bool TryWriteSignificandLittleEndian(TSelf x, Span<byte> destination, out int bytesWritten) => x.TryWriteSignificandLittleEndian(destination, out bytesWritten);
-		public static int WriteExponentBigEndian(TSelf x, byte[] destination) => x.WriteExponentBigEndian(destination);
-		public static int WriteExponentBigEndian(TSelf x, byte[] destination, int startIndex) => x.WriteExponentBigEndian(destination, startIndex);
-		public static int WriteExponentBigEndian(TSelf x, Span<byte> destination) => x.WriteExponentBigEndian(destination);
-		public static int WriteExponentLittleEndian(TSelf x, byte[] destination) => x.WriteExponentLittleEndian(destination);
-		public static int WriteExponentLittleEndian(TSelf x, byte[] destination, int startIndex) => x.WriteExponentLittleEndian(destination, startIndex);
-		public static int WriteExponentLittleEndian(TSelf x, Span<byte> destination) => x.WriteExponentLittleEndian(destination);
-		public static int WriteSignificandBigEndian(TSelf x, byte[] destination) => x.WriteSignificandBigEndian(destination);
-		public static int WriteSignificandBigEndian(TSelf x, byte[] destination, int startIndex) => x.WriteSignificandBigEndian(destination, startIndex);
-		public static int WriteSignificandBigEndian(TSelf x, Span<byte> destination) => x.WriteSignificandBigEndian(destination);
-		public static int WriteSignificandLittleEndian(TSelf x, byte[] destination) => x.WriteSignificandLittleEndian(destination);
-		public static int WriteSignificandLittleEndian(TSelf x, byte[] destination, int startIndex) => x.WriteSignificandLittleEndian(destination, startIndex);
-		public static int WriteSignificandLittleEndian(TSelf x, Span<byte> destination) => x.WriteSignificandLittleEndian(destination);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/FloatingPointIeee754.cs b/src/MissingValues.Tests/Helpers/FloatingPointIeee754.cs
deleted file mode 100644
index 60a45d9..0000000
--- a/src/MissingValues.Tests/Helpers/FloatingPointIeee754.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class FloatingPointIeee754<TSelf>
-		where TSelf : IFloatingPointIeee754<TSelf>
-	{
-		public static TSelf Epsilon => TSelf.Epsilon;
-		public static TSelf NaN => TSelf.NaN;
-		public static TSelf NegativeInfinity => TSelf.NegativeInfinity;
-		public static TSelf NegativeZero => TSelf.NegativeZero;
-		public static TSelf PositiveInfinity => TSelf.PositiveInfinity;
-		public static TSelf Atan2(TSelf y, TSelf x) => TSelf.Atan2(y, x);
-		public static TSelf Atan2Pi(TSelf y, TSelf x) => TSelf.Atan2Pi(y, x);
-		public static TSelf BitDecrement(TSelf x) => TSelf.BitDecrement(x);
-		public static TSelf BitIncrement(TSelf x) => TSelf.BitIncrement(x);
-		public static TSelf FusedMultiplyAdd(TSelf left, TSelf right, TSelf addend) => TSelf.FusedMultiplyAdd(left, right, addend);
-		public static TSelf Ieee754Remainder(TSelf left, TSelf right) => TSelf.Ieee754Remainder(left, right);
-		public static int ILogB(TSelf x) => TSelf.ILogB(x);
-		public static TSelf ReciprocalEstimate(TSelf x) => TSelf.ReciprocalEstimate(x);
-		public static TSelf ReciprocalSqrtEstimate(TSelf x) => TSelf.ReciprocalSqrtEstimate(x);
-		public static TSelf ScaleB(TSelf x, int n) => TSelf.ScaleB(x, n);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/FluentAssertionsExtensions.cs b/src/MissingValues.Tests/Helpers/FluentAssertionsExtensions.cs
deleted file mode 100644
index 5c2c878..0000000
--- a/src/MissingValues.Tests/Helpers/FluentAssertionsExtensions.cs
+++ /dev/null
@@ -1,247 +0,0 @@
-using FluentAssertions.Execution;
-using FluentAssertions.Numeric;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.Versioning;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	public static class FluentAssertionsExtensions
-	{
-		private class QuadAssertions : NumericAssertions<Quad>
-		{
-            internal QuadAssertions(Quad value)
-				: base(value)
-            {
-            }
-        }
-		private class NullableQuadAssertions : NullableNumericAssertions<Quad>
-		{
-            internal NullableQuadAssertions(Quad? value)
-				: base(value)
-            {
-            }
-        }
-		private class OctoAssertions : NumericAssertions<Octo>
-		{
-            internal OctoAssertions(Octo value)
-				: base(value)
-            {
-            }
-        }
-		private class NullableOctoAssertions : NullableNumericAssertions<Octo>
-		{
-            internal NullableOctoAssertions(Octo? value)
-				: base(value)
-            {
-            }
-        }
-
-		public static NumericAssertions<Quad> Should(this Quad actualValue)
-		{
-			return new QuadAssertions(actualValue);
-		}
-		public static NullableNumericAssertions<Quad> Should(this Quad? actualValue)
-		{
-			return new NullableQuadAssertions(actualValue);
-		}
-		public static NumericAssertions<Octo> Should(this Octo actualValue)
-		{
-			return new OctoAssertions(actualValue);
-		}
-		public static NullableNumericAssertions<Octo> Should(this Octo? actualValue)
-		{
-			return new NullableOctoAssertions(actualValue);
-		}
-
-		public static AndConstraint<NumericAssertions<Quad>> BeApproximately(this NumericAssertions<Quad> parent, Quad expectedValue, Quad precision, string because = "", params object[] becauseArgs)
-		{
-			if (Quad.IsNaN(expectedValue))
-			{
-				throw new ArgumentException("Cannot determine approximation of a Quad to NaN", nameof(expectedValue));
-			}
-			if (Quad.IsNegative(precision))
-			{
-				throw new ArgumentException("Cannot determine precision of a Quad if its negative", nameof(expectedValue));
-			}
-
-			if (Quad.IsPositiveInfinity(expectedValue))
-			{
-				FailIfDifferenceOutsidePrecision(Quad.IsPositiveInfinity(parent.Subject.Value), parent, expectedValue, precision,
-				Quad.NaN, because, becauseArgs);
-			}
-			else if (Quad.IsNegativeInfinity(expectedValue))
-			{
-				FailIfDifferenceOutsidePrecision(Quad.IsNegativeInfinity(parent.Subject.Value), parent, expectedValue, precision,
-				Quad.NaN, because, becauseArgs);
-			}
-			else
-			{
-				Quad actualDifference = Quad.Abs(expectedValue - parent.Subject.Value);
-
-				FailIfDifferenceOutsidePrecision(actualDifference <= precision, parent, expectedValue, precision, actualDifference, because, becauseArgs);
-			}
-
-			return new AndConstraint<NumericAssertions<Quad>>(parent);
-		}
-		public static AndConstraint<NumericAssertions<Octo>> BeApproximately(this NumericAssertions<Octo> parent, Octo expectedValue, Octo precision, string because = "", params object[] becauseArgs)
-		{
-			if (Octo.IsNaN(expectedValue))
-			{
-				throw new ArgumentException("Cannot determine approximation of a Quad to NaN", nameof(expectedValue));
-			}
-			if (Octo.IsNegative(precision))
-			{
-				throw new ArgumentException("Cannot determine precision of a Quad if its negative", nameof(expectedValue));
-			}
-
-			if (Octo.IsPositiveInfinity(expectedValue))
-			{
-				FailIfDifferenceOutsidePrecision(Octo.IsPositiveInfinity(parent.Subject.Value), parent, expectedValue, precision,
-				Octo.NaN, because, becauseArgs);
-			}
-			else if (Octo.IsNegativeInfinity(expectedValue))
-			{
-				FailIfDifferenceOutsidePrecision(Octo.IsNegativeInfinity(parent.Subject.Value), parent, expectedValue, precision,
-				Octo.NaN, because, becauseArgs);
-			}
-			else
-			{
-				Octo actualDifference = Octo.Abs(expectedValue - parent.Subject.Value);
-
-				FailIfDifferenceOutsidePrecision(actualDifference <= precision, parent, expectedValue, precision, actualDifference, because, becauseArgs);
-			}
-
-			return new AndConstraint<NumericAssertions<Octo>>(parent);
-		}
-
-		public static AndConstraint<NumericAssertions<Quad>> BeNaN(this NumericAssertions<Quad> parent, string because = "", params object[] becauseArgs)
-		{
-			bool condition = Quad.IsNaN(parent.Subject!.Value);
-
-			Execute.Assertion
-			.ForCondition(condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be {0}.", Quad.NaN);
-
-			return new AndConstraint<NumericAssertions<Quad>>(parent);
-		}
-		public static AndConstraint<NumericAssertions<Octo>> BeNaN(this NumericAssertions<Octo> parent, string because = "", params object[] becauseArgs)
-		{
-			bool condition = Octo.IsNaN(parent.Subject!.Value);
-
-			Execute.Assertion
-			.ForCondition(condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be {0}.", Octo.NaN);
-
-			return new AndConstraint<NumericAssertions<Octo>>(parent);
-		}
-
-		private static void FailIfDifferenceOutsidePrecision<T>(
-			bool differenceWithinPrecision,
-			NumericAssertions<T> parent, T expectedValue, T precision, T actualDifference,
-			string because, object[] becauseArgs)
-			where T : struct, IComparable<T>
-		{
-			Execute.Assertion
-			.ForCondition(differenceWithinPrecision)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:value} to approximate {1} +/- {2}{reason}, but {0} differed by {3}.",
-				parent.Subject, expectedValue, precision, actualDifference);
-		}
-
-		public static AndConstraint<NumericAssertions<Quad>> BeBitwiseEquivalentTo(this NumericAssertions<Quad, NumericAssertions<Quad>> assertions, Quad expected, string because = "", params object[] becauseArgs)
-		{
-			bool condition;
-
-			Quad actualValue = assertions.Subject is null ? default : (Quad)assertions.Subject;
-
-			if (Quad.IsNaN(actualValue) && Quad.IsNaN(expected))
-			{
-				condition = true;
-			}
-			else
-			{
-				condition = Equals(Quad.QuadToUInt128Bits(actualValue), Quad.QuadToUInt128Bits(expected));
-			}
-
-			Execute.Assertion
-			.ForCondition(condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be equal to {0}{reason}, but found {1}.", expected, assertions.Subject);
-
-			return new AndConstraint<NumericAssertions<Quad>>((NumericAssertions<Quad>)assertions);
-		}
-		public static AndConstraint<NumericAssertions<Octo>> BeBitwiseEquivalentTo(this NumericAssertions<Octo, NumericAssertions<Octo>> assertions, Octo expected, string because = "", params object[] becauseArgs)
-		{
-			bool condition;
-
-			Octo actualValue = assertions.Subject is null ? default : (Octo)assertions.Subject;
-
-			if (Octo.IsNaN(actualValue) && Octo.IsNaN(expected))
-			{
-				condition = true;
-			}
-			else
-			{
-				condition = Equals(Octo.OctoToUInt256Bits(actualValue), Octo.OctoToUInt256Bits(expected));
-			}
-
-			Execute.Assertion
-			.ForCondition(condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be equal to {0}{reason}, but found {1}.", expected, assertions.Subject);
-
-			return new AndConstraint<NumericAssertions<Octo>>((NumericAssertions<Octo>)assertions);
-		}
-
-		public static AndConstraint<NumericAssertions<Quad>> NotBeBitwiseEquivalentTo(this NumericAssertions<Quad, NumericAssertions<Quad>> assertions, Quad expected, string because = "", params object[] becauseArgs)
-		{
-			bool condition;
-
-			Quad actualValue = assertions.Subject is null ? default : (Quad)assertions.Subject;
-
-			if (Quad.IsNaN(actualValue) && Quad.IsNaN(expected))
-			{
-				condition = true;
-			}
-			else
-			{
-				condition = Equals(Quad.QuadToUInt128Bits(actualValue), Quad.QuadToUInt128Bits(expected));
-			}
-
-			Execute.Assertion
-			.ForCondition(!condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be equal to {0}{reason}, but found {1}.", expected, assertions.Subject);
-
-			return new AndConstraint<NumericAssertions<Quad>>((NumericAssertions<Quad>)assertions);
-		}
-		public static AndConstraint<NumericAssertions<Octo>> NotBeBitwiseEquivalentTo(this NumericAssertions<Octo, NumericAssertions<Octo>> assertions, Octo expected, string because = "", params object[] becauseArgs)
-		{
-			bool condition;
-
-			Octo actualValue = assertions.Subject is null ? default : (Octo)assertions.Subject;
-
-			if (Octo.IsNaN(actualValue) && Octo.IsNaN(expected))
-			{
-				condition = true;
-			}
-			else
-			{
-				condition = Equals(Octo.OctoToUInt256Bits(actualValue), Octo.OctoToUInt256Bits(expected));
-			}
-
-			Execute.Assertion
-			.ForCondition(!condition)
-			.BecauseOf(because, becauseArgs)
-			.FailWith("Expected {context:object} to be equal to {0}{reason}, but found {1}.", expected, assertions.Subject);
-
-			return new AndConstraint<NumericAssertions<Octo>>((NumericAssertions<Octo>)assertions);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/GenericFloatingPointFunctions.cs b/src/MissingValues.Tests/Helpers/GenericFloatingPointFunctions.cs
deleted file mode 100644
index 7477cbf..0000000
--- a/src/MissingValues.Tests/Helpers/GenericFloatingPointFunctions.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class GenericFloatingPointFunctions
-	{
-		public static T Acos<T>(T x) where T : ITrigonometricFunctions<T> => T.Acos(x);
-		public static T Acosh<T>(T x) where T : IHyperbolicFunctions<T> => T.Acosh(x);
-		public static T AcosPi<T>(T x) where T : ITrigonometricFunctions<T> => T.AcosPi(x);
-		public static T Asin<T>(T x) where T : ITrigonometricFunctions<T> => T.Asin(x);
-		public static T Asinh<T>(T x) where T : IHyperbolicFunctions<T> => T.Asinh(x);
-		public static T AsinPi<T>(T x) where T : ITrigonometricFunctions<T> => T.AsinPi(x);
-		public static T Atan<T>(T x) where T : ITrigonometricFunctions<T> => T.Atan(x);
-		public static T AtanPi<T>(T x) where T : ITrigonometricFunctions<T> => T.AtanPi(x);
-		public static T Atanh<T>(T x) where T : IHyperbolicFunctions<T> => T.Atanh(x);
-		public static T Cbrt<T>(T x) where T : IRootFunctions<T> => T.Cbrt(x);
-		public static T Cos<T>(T x) where T : ITrigonometricFunctions<T> => T.Cos(x);
-		public static T Cosh<T>(T x) where T : IHyperbolicFunctions<T> => T.Cosh(x);
-		public static T CosPi<T>(T x) where T : ITrigonometricFunctions<T> => T.CosPi(x);
-		public static T Exp<T>(T x) where T : IExponentialFunctions<T> => T.Exp(x);
-		public static T ExpM1<T>(T x) where T : IExponentialFunctions<T> => T.ExpM1(x);
-		public static T Exp2<T>(T x) where T : IExponentialFunctions<T> => T.Exp2(x);
-		public static T Exp2M1<T>(T x) where T : IExponentialFunctions<T> => T.Exp2M1(x);
-		public static T Exp10<T>(T x) where T : IExponentialFunctions<T> => T.Exp10(x);
-		public static T Exp10M1<T>(T x) where T : IExponentialFunctions<T> => T.Exp10M1(x);
-		public static T Hypot<T>(T x, T y) where T : IRootFunctions<T> => T.Hypot(x, y);
-		public static T Log<T>(T x) where T : ILogarithmicFunctions<T> => T.Log(x);
-		public static T Log<T>(T x, T newBase) where T : ILogarithmicFunctions<T> => T.Log(x, newBase);
-		public static T LogP1<T>(T x) where T : ILogarithmicFunctions<T> => T.LogP1(x);
-		public static T Log2<T>(T x) where T : ILogarithmicFunctions<T> => T.Log2(x);
-		public static T Log2P1<T>(T x) where T : ILogarithmicFunctions<T> => T.Log2P1(x);
-		public static T Log10<T>(T x) where T : ILogarithmicFunctions<T> => T.Log10(x);
-		public static T Log10P1<T>(T x) where T : ILogarithmicFunctions<T> => T.Log10P1(x);
-		public static T Pow<T>(T x, T y) where T : IPowerFunctions<T> => T.Pow(x, y);
-		public static T RootN<T>(T x, int y) where T : IRootFunctions<T> => T.RootN(x, y);
-		public static T Sin<T>(T x) where T : ITrigonometricFunctions<T> => T.Sin(x);
-		public static (T Sin, T Cos) SinCos<T>(T x) where T : ITrigonometricFunctions<T> => T.SinCos(x);
-		public static (T Sin, T Cos) SinCosPi<T>(T x) where T : ITrigonometricFunctions<T> => T.SinCosPi(x);
-		public static T Sinh<T>(T x) where T : IHyperbolicFunctions<T> => T.Sinh(x);
-		public static T SinPi<T>(T x) where T : ITrigonometricFunctions<T> => T.SinPi(x);
-		public static T Sqrt<T>(T x) where T : IRootFunctions<T> => T.Sqrt(x);
-		public static T Tan<T>(T x) where T : ITrigonometricFunctions<T> => T.Tan(x);
-		public static T Tanh<T>(T x) where T : IHyperbolicFunctions<T> => T.Tanh(x);
-		public static T TanPi<T>(T x) where T : ITrigonometricFunctions<T> => T.TanPi(x);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/GenericMathOperatorsHelper.cs b/src/MissingValues.Tests/Helpers/GenericMathOperatorsHelper.cs
deleted file mode 100644
index 3d49662..0000000
--- a/src/MissingValues.Tests/Helpers/GenericMathOperatorsHelper.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-using Microsoft.VisualStudio.TestPlatform.ObjectModel;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class MathOperatorsHelper
-	{
-		public static TResult AdditionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IAdditionOperators<TSelf, TOther, TResult>
-		{
-			return left + right;
-		}
-		public static TResult CheckedAdditionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IAdditionOperators<TSelf, TOther, TResult>
-		{
-			return checked(left + right);
-		}
-
-		public static TSelf IncrementOperation<TSelf>(TSelf value)
-			where TSelf : IIncrementOperators<TSelf>
-		{
-			return ++value;
-		}
-		public static TSelf CheckedIncrementOperation<TSelf>(TSelf value)
-			where TSelf : IIncrementOperators<TSelf>
-		{
-			return checked(++value);
-		}
-
-		public static TResult UnaryPlusOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryPlusOperators<TSelf, TResult>
-		{
-			return +value;
-		}
-		public static TResult CheckedUnaryPlusOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryPlusOperators<TSelf, TResult>
-		{
-			return checked(+value);
-		}
-		
-		public static TResult UnaryNegationOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryNegationOperators<TSelf, TResult>
-		{
-			return -value;
-		}
-		public static TResult CheckedUnaryNegationOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryNegationOperators<TSelf, TResult>
-		{
-			return checked(-value);
-		}
-		
-		public static TResult SubtractionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : ISubtractionOperators<TSelf, TOther, TResult>
-		{
-			return left - right;
-		}
-		public static TResult CheckedSubtractionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : ISubtractionOperators<TSelf, TOther, TResult>
-		{
-			return checked(left - right);
-		}
-
-		public static TSelf DecrementOperation<TSelf>(TSelf value)
-			where TSelf : IDecrementOperators<TSelf>
-		{
-			return --value;
-		}
-		public static TSelf CheckedDecrementOperation<TSelf>(TSelf value)
-			where TSelf : IDecrementOperators<TSelf>
-		{
-			return checked(--value);
-		}
-
-		public static TResult MultiplicationOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IMultiplyOperators<TSelf, TOther, TResult>
-		{
-			return left * right;
-		}
-		public static TResult CheckedMultiplicationOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IMultiplyOperators<TSelf, TOther, TResult>
-		{
-			return checked(left * right);
-		}
-		
-		public static TResult DivisionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IDivisionOperators<TSelf, TOther, TResult>
-		{
-			return left / right;
-		}
-		public static TResult CheckedDivisionOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IDivisionOperators<TSelf, TOther, TResult>
-		{
-			return checked(left / right);
-		}
-
-		public static TResult ModulusOperation<TSelf, TOther, TResult>(TSelf left, TOther right)
-			where TSelf : IModulusOperators<TSelf, TOther, TResult>
-		{
-			return left % right;
-		}
-	}
-
-    internal static class ComparisonOperatorsHelper<TSelf, TOther, TResult>
-		where TSelf : IComparisonOperators<TSelf, TOther, TResult>
-	{
-		public static TResult GreaterThanOperation(TSelf left, TOther right)
-		{
-			return left > right;
-		}
-		public static TResult GreaterThanOrEqualOperation(TSelf left, TOther right)
-		{
-			return left >= right;
-		}
-		public static TResult LessThanOperation(TSelf left, TOther right)
-		{
-			return left < right;
-		}
-		public static TResult LessThanOrEqualOperation(TSelf left, TOther right)
-		{
-			return left <= right;
-		}
-	}
-
-    internal static class EqualityOperatorsHelper<TSelf, TOther, TResult>
-		where TSelf : IEqualityOperators<TSelf, TOther, TResult>
-	{
-		public static TResult EqualityOperation(TSelf left, TOther right)
-		{
-			return left == right;
-		}
-		public static TResult InequalityOperation(TSelf left, TOther right)
-		{
-			return left != right;
-		}
-	}
-
-    internal static class BitwiseOperatorsHelper<TSelf, TOther, TResult>
-		where TSelf : IBitwiseOperators<TSelf, TOther, TResult>
-	{
-		public static TResult BitwiseAndOperation(TSelf left, TOther right)
-		{
-			return left & right;
-		}
-		public static TResult BitwiseOrOperation(TSelf left, TOther right)
-		{
-			return left | right;
-		}
-		public static TResult ExclusiveOrOperation(TSelf left, TOther right)
-		{
-			return left ^ right;
-		}
-		public static TResult OnesComplementOperation(TSelf value)
-		{
-			return ~value;
-		}
-	}
-	internal static class ShiftOperatorsHelper<TSelf, TOther, TResult>
-		where TSelf : IShiftOperators<TSelf, TOther, TResult>
-	{
-		public static TResult LeftShiftOperation(TSelf value, TOther shiftAmount)
-		{
-			return value << shiftAmount;
-		}
-		public static TResult RightShiftOperation(TSelf value, TOther shiftAmount)
-		{
-			return value >> shiftAmount;
-		}
-		public static TResult UnsignedRightShiftOperation(TSelf value, TOther shiftAmount)
-		{
-			return value >>> shiftAmount;
-		}
-	}
-
-	internal static class UnaryOperatorsHelper
-	{
-		public static TResult UnaryPlusOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryPlusOperators<TSelf, TResult>
-		{
-			return +value;
-		}
-		public static TResult UnaryNegationOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryNegationOperators<TSelf, TResult>
-		{
-			return -value;
-		}
-		public static TResult CheckedUnaryNegationOperation<TSelf, TResult>(TSelf value)
-			where TSelf : IUnaryNegationOperators<TSelf, TResult>
-		{
-			return checked(-value);
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/MathConstantsHelper.cs b/src/MissingValues.Tests/Helpers/MathConstantsHelper.cs
deleted file mode 100644
index f9e9a7f..0000000
--- a/src/MissingValues.Tests/Helpers/MathConstantsHelper.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class MathConstantsHelper
-	{
-		/// <inheritdoc cref="IAdditiveIdentity{TSelf, TResult}.AdditiveIdentity"/>
-		public static TResult AdditiveIdentityHelper<TSelf, TResult>()
-			where TSelf : IAdditiveIdentity<TSelf, TResult>
-		{
-			return TSelf.AdditiveIdentity;
-		}
-		/// <inheritdoc cref="IMultiplicativeIdentity{TSelf, TResult}.MultiplicativeIdentity"/>
-		public static TResult MultiplicativeIdentityHelper<TSelf, TResult>()
-			where TSelf : IMultiplicativeIdentity<TSelf, TResult>
-		{
-			return TSelf.MultiplicativeIdentity;
-		}
-		/// <inheritdoc cref="IMinMaxValue{TSelf}.MaxValue"/>
-		public static TSelf MaxValue<TSelf>()
-			where TSelf : IMinMaxValue<TSelf>
-		{
-			return TSelf.MaxValue;
-		}
-		/// <inheritdoc cref="IMinMaxValue{TSelf}.MinValue"/>
-		public static TSelf MinValue<TSelf>()
-			where TSelf : IMinMaxValue<TSelf>
-		{
-			return TSelf.MinValue;
-		}
-		/// <inheritdoc cref="ISignedNumber{TSelf}.NegativeOne"/>
-		public static TSelf NegativeOne<TSelf>()
-			where TSelf : ISignedNumber<TSelf>
-		{
-			return TSelf.NegativeOne;
-		}
-		public static TSelf Pi<TSelf>()
-			where TSelf : IFloatingPointConstants<TSelf>
-		{
-			return TSelf.Pi;
-		}
-		public static TSelf Tau<TSelf>()
-			where TSelf : IFloatingPointConstants<TSelf>
-		{
-			return TSelf.Tau;
-		}
-		public static TSelf E<TSelf>()
-			where TSelf : IFloatingPointConstants<TSelf>
-		{
-			return TSelf.E;
-		}
-		public static TSelf PositiveInfinity<TSelf>()
-			where TSelf : IFloatingPointIeee754<TSelf>
-		{
-			return TSelf.PositiveInfinity;
-		}
-		public static TSelf NegativeInfinity<TSelf>()
-			where TSelf : IFloatingPointIeee754<TSelf>
-		{
-			return TSelf.NegativeInfinity;
-		}
-		public static TSelf NaN<TSelf>()
-			where TSelf : IFloatingPointIeee754<TSelf>
-		{
-			return TSelf.NaN;
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/NumberBaseHelper.cs b/src/MissingValues.Tests/Helpers/NumberBaseHelper.cs
deleted file mode 100644
index ebe5241..0000000
--- a/src/MissingValues.Tests/Helpers/NumberBaseHelper.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class NumberBaseHelper<TSelf>
-		where TSelf : INumberBase<TSelf>
-	{
-		public static TSelf One => TSelf.One;
-		public static int Radix => TSelf.Radix;
-		public static TSelf Zero => TSelf.Zero;
-		public static TSelf Abs(TSelf value) => TSelf.Abs(value);
-
-		public static TSelf CreateChecked<TOther>(TOther value)
-			where TOther : INumberBase<TOther> => TSelf.CreateChecked(value);
-		public static TSelf CreateSaturating<TOther>(TOther value)
-			where TOther : INumberBase<TOther> => TSelf.CreateSaturating(value);
-		public static TSelf CreateTruncating<TOther>(TOther value)
-			where TOther : INumberBase<TOther> => TSelf.CreateTruncating(value);
-
-		public static bool IsCanonical(TSelf value) => TSelf.IsCanonical(value);
-		public static bool IsComplexNumber(TSelf value) => TSelf.IsComplexNumber(value);
-		public static bool IsEvenInteger(TSelf value) => TSelf.IsEvenInteger(value);
-		public static bool IsFinite(TSelf value) => TSelf.IsFinite(value);
-		public static bool IsImaginaryNumber(TSelf value) => TSelf.IsImaginaryNumber(value);
-		public static bool IsInfinity(TSelf value) => TSelf.IsInfinity(value);
-		public static bool IsInteger(TSelf value) => TSelf.IsInteger(value);
-		public static bool IsNaN(TSelf value) => TSelf.IsNaN(value);
-		public static bool IsNegative(TSelf value) => TSelf.IsNegative(value);
-		public static bool IsNegativeInfinity(TSelf value) => TSelf.IsNegativeInfinity(value);
-		public static bool IsNormal(TSelf value) => TSelf.IsNormal(value);
-		public static bool IsOddInteger(TSelf value) => TSelf.IsOddInteger(value);
-		public static bool IsPositive(TSelf value) => TSelf.IsPositive(value);
-		public static bool IsPositiveInfinity(TSelf value) => TSelf.IsPositiveInfinity(value);
-		public static bool IsRealNumber(TSelf value) => TSelf.IsRealNumber(value);
-		public static bool IsSubnormal(TSelf value) => TSelf.IsSubnormal(value);
-		public static bool IsZero(TSelf value) => TSelf.IsZero(value);
-
-		public static TSelf MaxMagnitude(TSelf x, TSelf y) => TSelf.MaxMagnitude(x, y);
-		public static TSelf MaxMagnitudeNumber(TSelf x, TSelf y) => TSelf.MaxMagnitudeNumber(x, y);
-		public static TSelf MinMagnitude(TSelf x, TSelf y) => TSelf.MinMagnitude(x, y);
-		public static TSelf MinMagnitudeNumber(TSelf x, TSelf y) => TSelf.MinMagnitudeNumber(x, y);
-
-		public static TSelf Parse(string s, NumberStyles style, IFormatProvider? provider) => TSelf.Parse(s, style, provider);
-		public static TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider) => TSelf.Parse(s, style, provider);
-		public static TSelf Parse(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFormatProvider? provider) => TSelf.Parse(utf8Text, style, provider);
-
-		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result) => TSelf.TryParse(s, style, provider, out result);
-		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result) => TSelf.TryParse(s, style, provider, out result);
-		public static bool TryParse(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result) => TSelf.TryParse(utf8Text, style, provider, out result);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/NumberHelper.cs b/src/MissingValues.Tests/Helpers/NumberHelper.cs
deleted file mode 100644
index f31d15d..0000000
--- a/src/MissingValues.Tests/Helpers/NumberHelper.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class NumberHelper<TSelf>
-		where TSelf : INumber<TSelf>
-	{
-		/// <inheritdoc cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/>
-		public static TSelf Clamp(TSelf value, TSelf min, TSelf max) => TSelf.Clamp(value, min, max);
-		/// <inheritdoc cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/>
-		public static TSelf CopySign(TSelf value, TSelf sign) => TSelf.CopySign(value, sign);
-		/// <inheritdoc cref="INumber{TSelf}.Max(TSelf, TSelf)"/>
-		public static TSelf Max(TSelf x, TSelf y) => TSelf.Max(x, y);
-		/// <inheritdoc cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/>
-		public static TSelf MaxNumber(TSelf x, TSelf y) => TSelf.MaxNumber(x, y);
-		/// <inheritdoc cref="INumber{TSelf}.Min(TSelf, TSelf)"/>
-		public static TSelf Min(TSelf x, TSelf y) => TSelf.Min(x, y);
-		/// <inheritdoc cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/>
-		public static TSelf MinNumber(TSelf x, TSelf y) => TSelf.MinNumber(x, y);
-		/// <inheritdoc cref="INumber{TSelf}.Sign(TSelf)"/>
-		public static int Sign(TSelf value) => TSelf.Sign(value);
-	}
-}
diff --git a/src/MissingValues.Tests/Helpers/TheoryDataTypes.cs b/src/MissingValues.Tests/Helpers/TheoryDataTypes.cs
deleted file mode 100644
index 29ef7b8..0000000
--- a/src/MissingValues.Tests/Helpers/TheoryDataTypes.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-using static System.Runtime.InteropServices.JavaScript.JSType;
-
-namespace MissingValues.Tests.Helpers
-{
-	public class NumberTheoryData<TSelf> : TheoryData<TSelf>
-		where TSelf : INumberBase<TSelf>
-	{
-        public NumberTheoryData(IEnumerable<TSelf> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat);
-			}
-        }
-    }
-
-	public class OperationTheoryData<TSelf, TOther, TResult> : TheoryData<TSelf, TOther, TResult>
-	{
-		public OperationTheoryData(IEnumerable<(TSelf, TOther, TResult)> data)
-		{
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2, dat.Item3);
-			}
-		}
-	}
-
-	public class FusedMultiplyAddTheoryData<TSelf> : TheoryData<TSelf, TSelf, TSelf, TSelf>
-		where TSelf : IFloatingPointIeee754<TSelf>
-	{
-        public FusedMultiplyAddTheoryData(IEnumerable<(TSelf, TSelf, TSelf, TSelf)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2, dat.Item3, dat.Item4);
-			}
-		}
-    }
-
-	public class RoundTheoryData<TFloat> : TheoryData<TFloat, int, MidpointRounding, TFloat>
-	{
-        public RoundTheoryData(IEnumerable<(TFloat, int, MidpointRounding, TFloat)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2, dat.Item3, dat.Item4);
-			}
-		}
-    }
-
-	public class UnaryTheoryData<TSelf, TResult> : TheoryData<TSelf, TResult>
-	{
-		public UnaryTheoryData(IEnumerable<(TSelf, TResult)> data)
-		{
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2);
-			}
-		}
-	}
-
-	public class CastingTheoryData<TFrom, TTo> : TheoryData<TFrom, TTo>
-	{
-        public CastingTheoryData(IEnumerable<(TFrom, TTo)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2);
-			}
-		}
-    }
-
-	public class ComparisonOperatorsTheoryData<TSelf, TOther> : TheoryData<TSelf, TOther, bool>
-	{
-        public ComparisonOperatorsTheoryData(IEnumerable<(TSelf, TOther, bool)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2, dat.Item3);
-			}
-		}
-    }
-
-	public class TryParseTheoryData<T> : TheoryData<string, bool, T>
-		where T : IParsable<T>
-	{
-		public TryParseTheoryData(IEnumerable<(string, bool, T)> data)
-		{
-			Contract.Assert(data is not null && data.Any());
-
-			foreach (var dat in data)
-			{
-				Add(dat.Item1, dat.Item2, dat.Item3);
-			}
-		}
-	}
-
-	public class FormatStringTheoryData : TheoryData<IFormattable, string, NumberFormatInfo?, string>
-	{
-        public FormatStringTheoryData(IEnumerable<(IFormattable, string, NumberFormatInfo?, string)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-            foreach (var dat in data)
-            {
-				Add(dat.Item1, dat.Item2, dat.Item3, dat.Item4);
-            }
-        }
-    }
-	public class FormatParsingTheoryData<TNumber> : TheoryData<string, NumberStyles, NumberFormatInfo?, TNumber, bool>
-		where TNumber : INumber<TNumber>
-	{
-        public FormatParsingTheoryData(IEnumerable<(string, NumberStyles, NumberFormatInfo?, TNumber, bool)> data)
-        {
-			Contract.Assert(data is not null && data.Any());
-
-            foreach (var dat in data)
-            {
-				Add(dat.Item1, dat.Item2, dat.Item3, dat.Item4, dat.Item5);
-            }
-        }
-    }
-}
diff --git a/src/MissingValues.Tests/Helpers/Values.cs b/src/MissingValues.Tests/Helpers/Values.cs
deleted file mode 100644
index 82df81d..0000000
--- a/src/MissingValues.Tests/Helpers/Values.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MissingValues.Tests.Helpers
-{
-	internal static class Values
-	{
-		public static TFloat CreateFloat<TFloat>(params ulong[] bits)
-			where TFloat : unmanaged, IBinaryFloatingPointIeee754<TFloat>
-		{
-			if (typeof(TFloat) == typeof(Quad) && bits.Length == 2)
-			{
-				return (TFloat)(object)Quad.UInt128BitsToQuad(new UInt128(bits[0], bits[1]));
-			}
-			else if (typeof(TFloat) == typeof(Octo) && bits.Length == 4)
-			{
-				return (TFloat)(object)Octo.UInt256BitsToOcto(new UInt256(bits[0], bits[1], bits[2], bits[3]));
-			}
-			else
-			{
-				throw new InvalidOperationException($"{typeof(TFloat)} does not match the bits({bits.Length}): {StringifyBits(bits)}");
-			}
-
-			static string StringifyBits(ReadOnlySpan<ulong> bits)
-			{
-				StringBuilder sb = new StringBuilder();
-
-				sb.Append($"0x{bits[0]:X16}");
-				for (int i = 1; i < bits.Length; i++)
-				{
-					sb.Append($"_{bits[i]:X16}");
-				}
-
-				return sb.ToString();
-			}
-		}
-	}
-}
diff --git a/src/MissingValues.Tests/MissingValues.Tests.csproj b/src/MissingValues.Tests/MissingValues.Tests.csproj
index 5a178aa..abf4ae0 100644
--- a/src/MissingValues.Tests/MissingValues.Tests.csproj
+++ b/src/MissingValues.Tests/MissingValues.Tests.csproj
@@ -1,30 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="7.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
+    <PackageReference Include="TUnit" Version="1.44.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\MissingValues\MissingValues.csproj" />
   </ItemGroup>
 
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Numerics/Int256GenericMathTests.cs b/src/MissingValues.Tests/Numerics/Int256GenericMathTests.cs
new file mode 100644
index 0000000..2d6e149
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/Int256GenericMathTests.cs
@@ -0,0 +1,806 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using MissingValues.Tests.Data;
+using static MissingValues.Tests.Data.Int256DataSources;
+
+using DataSources = MissingValues.Tests.Data.Int256DataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class Int256GenericMathTests
+{
+	#region Operators
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+	public async Task op_AdditionTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left + right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedAdditionTestData))]
+	public async Task op_CheckedAdditionTest(Int256 left, Int256 right, Int256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left + right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left + right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+	public async Task op_IncrementTest(Int256 value, Int256 expected)
+	{
+		var result = ++value;
+		
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedIncrementTestData))]
+	public async Task op_CheckedIncrementTest(Int256 value, Int256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(++value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(++value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+	public async Task op_SubtractionTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left - right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedSubtractionTestData))]
+	public async Task op_CheckedSubtractionTest(Int256 left, Int256 right, Int256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left - right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left - right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+	public async Task op_DecrementTest(Int256 value, Int256 expected)
+	{
+		var result = --value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedDecrementTestData))]
+	public async Task op_CheckedDecrementTest(Int256 value, Int256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(--value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(--value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+	public async Task op_MultiplyTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left * right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedMultiplyTestData))]
+	public async Task op_CheckedMultiplyTest(Int256 left, Int256 right, Int256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left * right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left * right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+	public async Task op_DivisionTest(Int256 left, Int256 right, Int256 expected)
+	{
+		if (right == Int256.Zero)
+		{
+			await Assert.That(() => left / right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left / right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+	public async Task op_ModulusTest(Int256 left, Int256 right, Int256 expected)
+	{
+		if (right == Int256.Zero)
+		{
+			await Assert.That(() => left % right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left % right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+	public async Task op_OnesComplementTest(Int256 value, Int256 expected)
+	{
+		var result = ~value;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+	public async Task op_BitwiseAndTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left & right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+	public async Task op_BitwiseOrTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left | right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+	public async Task op_BitwiseXorTest(Int256 left, Int256 right, Int256 expected)
+	{
+		var result = left ^ right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftLeftTestData))]
+	public async Task op_ShiftLeftTest(Int256 value, int shiftAmount, Int256 expected)
+	{
+		var result = value << shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftRightTestData))]
+	public async Task op_ShiftRightTest(Int256 value, int shiftAmount, Int256 expected)
+	{
+		var result = value >> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_UnsignedShiftRightTestData))]
+	public async Task op_UnsignedShiftRightTest(Int256 value, int shiftAmount, Int256 expected)
+	{
+		var result = value >>> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+	public async Task op_EqualityTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left == right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+	public async Task op_InequalityTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left != right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+	public async Task op_LessThanTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left < right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+	public async Task op_LessThanOrEqualTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left <= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+	public async Task op_GreaterThanTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left > right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+	public async Task op_GreaterThanOrEqualTest(Int256 left, Int256 right, bool expected)
+	{
+		var result = left >= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region INumberBase
+	[Test]
+	[MethodDataSource<DataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(Int256 value, Int256 expected)
+	{
+		Int256 result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(Int256 value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(Int256 left, Int256 right, Int256 addend, Int256 expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, Int256 expected)
+	{
+		var result = Helper.Parse<Int256>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, Int256 expected)
+	{
+		var result = Helper.Parse<Int256>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, Int256 expected)
+	{
+		var result = Helper.Parse<Int256>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, Int256 expectedValue)
+	{
+		var success = Helper.TryParse<Int256>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, Int256 expectedValue)
+	{
+		var success = Helper.TryParse<Int256>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, Int256 expectedValue)
+	{
+		var success = Helper.TryParse<Int256>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(Int256 value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+	#endregion
+	
+	#region INumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ClampTestData))]
+	public async Task ClampTest(Int256 value, Int256 min, Int256 max, Int256 expected)
+	{
+		if (min > max)
+		{
+			await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+		}
+		else
+		{
+			var result = Helper.Clamp(value, min, max);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(CopySignTestData))]
+	public async Task CopySignTest(Int256 value, Int256 sign, Int256 expected)
+	{
+		var result = Helper.CopySign(value, sign);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxTestData))]
+	public async Task MaxTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.Max(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+	public async Task MaxNumberTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MaxNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinTestData))]
+	public async Task MinTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.Min(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+	public async Task MinNumberTest(Int256 x, Int256 y, Int256 expected)
+	{
+		var result = Helper.MinNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(SignTestData))]
+	public async Task SignTest(Int256 value, int expected)
+	{
+		var result = Helper.Sign(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryNumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+	public async Task IsPow2Test(Int256 value, bool expected)
+	{
+		var result = Helper.IsPow2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(Log2TestData))]
+	public async Task Log2Test(Int256 value, Int256 expected)
+	{
+		var result = Helper.Log2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryInteger
+	[Test]
+	[MethodDataSource<DataSources>(nameof(DivRemTestData))]
+	public async Task DivRemTest(Int256 left, Int256 right, Pair<Int256> expected)
+	{
+		var result = Helper.DivRem(left, right);
+		await Assert.That((Pair<Int256>)result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(LeadingZeroCountTestData))]
+	public async Task LeadingZeroCountTest(Int256 value, Int256 expected)
+	{
+		var result = Helper.LeadingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(PopCountTestData))]
+	public async Task PopCountTest(Int256 value, Int256 expected)
+	{
+		var result = Helper.PopCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadBigEndianTestData))]
+	public async Task ReadBigEndianTest(byte[] source, bool isUnsigned, Int256 expected)
+	{
+		var result = Helper.ReadBigEndian<Int256>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadLittleEndianTestData))]
+	public async Task ReadLittleEndianTest(byte[] source, bool isUnsigned, Int256 expected)
+	{
+		var result = Helper.ReadLittleEndian<Int256>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateLeftTestData))]
+	public async Task RotateLeftTest(Int256 value, int shiftAmount, Int256 expected)
+	{
+		var result = Helper.RotateLeft(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateRightTestData))]
+	public async Task RotateRightTest(Int256 value, int shiftAmount, Int256 expected)
+	{
+		var result = Helper.RotateRight(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TrailingZeroCountTestData))]
+	public async Task TrailingZeroCountTest(Int256 value, Int256 expected)
+	{
+		var result = Helper.TrailingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetByteCountTestData))]
+	public async Task GetByteCountTest(Int256 value, int expected)
+	{
+		var result = Helper.GetByteCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetShortestBitLengthTestData))]
+	public async Task GetShortestBitLengthTest(Int256 value, int expected)
+	{
+		var result = Helper.GetShortestBitLength(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteBigEndianTestData))]
+	public async Task WriteBigEndianTest(Int256 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[Int256.Size];
+		var result = Helper.WriteBigEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteLittleEndianTestData))]
+	public async Task WriteLittleEndianTest(Int256 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[Int256.Size];
+		var result = Helper.WriteLittleEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	#endregion
+
+	#region Conversion
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(Int256 input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(Int256 input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(Int256 input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(Int256 input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(Int256 input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(Int256 input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(Int256 input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(Int256 input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(Int256 input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(Int256 input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(Int256 input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(Int256 input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(Int256 input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(Int256 input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(Int256 input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt256TestData))] public async Task ConvertToCheckedUInt256Test(Int256 input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt256TestData))] public async Task ConvertToSaturatingUInt256Test(Int256 input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt256TestData))] public async Task ConvertToTruncatingUInt256Test(Int256 input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt512TestData))] public async Task ConvertToCheckedUInt512Test(Int256 input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt512TestData))] public async Task ConvertToSaturatingUInt512Test(Int256 input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt512TestData))] public async Task ConvertToTruncatingUInt512Test(Int256 input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(Int256 input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(Int256 input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(Int256 input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(Int256 input, short expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(Int256 input, short expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(Int256 input, short expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(Int256 input, int expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(Int256 input, int expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(Int256 input, int expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(Int256 input, long expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(Int256 input, long expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(Int256 input, long expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(Int256 input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(Int256 input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(Int256 input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt512TestData))] public async Task ConvertToCheckedInt512Test(Int256 input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt512TestData))] public async Task ConvertToSaturatingInt512Test(Int256 input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt512TestData))] public async Task ConvertToTruncatingInt512Test(Int256 input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(Int256 input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(Int256 input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(Int256 input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(Int256 input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(Int256 input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(Int256 input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(Int256 input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(Int256 input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(Int256 input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(Int256 input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(Int256 input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(Int256 input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedQuadTestData))] public async Task ConvertToCheckedQuadTest(Int256 input, Quad expected) => await Assert.That(Quad.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingQuadTestData))] public async Task ConvertToSaturatingQuadTest(Int256 input, Quad expected) => await Assert.That(Quad.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingQuadTestData))] public async Task ConvertToTruncatingQuadTest(Int256 input, Quad expected) => await Assert.That(Quad.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedOctoTestData))] public async Task ConvertToCheckedOctoTest(Int256 input, Octo expected) => await Assert.That(Octo.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingOctoTestData))] public async Task ConvertToSaturatingOctoTest(Int256 input, Octo expected) => await Assert.That(Octo.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingOctoTestData))] public async Task ConvertToTruncatingOctoTest(Int256 input, Octo expected) => await Assert.That(Octo.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+	#endregion
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Numerics/Int512GenericMathTests.cs b/src/MissingValues.Tests/Numerics/Int512GenericMathTests.cs
new file mode 100644
index 0000000..3d2f431
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/Int512GenericMathTests.cs
@@ -0,0 +1,805 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using static MissingValues.Tests.Data.Int512DataSources;
+
+using DataSources = MissingValues.Tests.Data.Int512DataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class Int512GenericMathTests
+{
+	#region Operators
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+	public async Task op_AdditionTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left + right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedAdditionTestData))]
+	public async Task op_CheckedAdditionTest(Int512 left, Int512 right, Int512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left + right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left + right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+	public async Task op_IncrementTest(Int512 value, Int512 expected)
+	{
+		var result = ++value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedIncrementTestData))]
+	public async Task op_CheckedIncrementTest(Int512 value, Int512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(++value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(++value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+	public async Task op_SubtractionTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left - right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedSubtractionTestData))]
+	public async Task op_CheckedSubtractionTest(Int512 left, Int512 right, Int512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left - right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left - right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+	public async Task op_DecrementTest(Int512 value, Int512 expected)
+	{
+		var result = --value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedDecrementTestData))]
+	public async Task op_CheckedDecrementTest(Int512 value, Int512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(--value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(--value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+	public async Task op_MultiplyTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left * right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedMultiplyTestData))]
+	public async Task op_CheckedMultiplyTest(Int512 left, Int512 right, Int512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left * right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left * right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+	public async Task op_DivisionTest(Int512 left, Int512 right, Int512 expected)
+	{
+		if (right == Int512.Zero)
+		{
+			await Assert.That(() => left / right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left / right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+	public async Task op_ModulusTest(Int512 left, Int512 right, Int512 expected)
+	{
+		if (right == Int512.Zero)
+		{
+			await Assert.That(() => left % right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left % right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+	public async Task op_OnesComplementTest(Int512 value, Int512 expected)
+	{
+		var result = ~value;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+	public async Task op_BitwiseAndTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left & right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+	public async Task op_BitwiseOrTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left | right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+	public async Task op_BitwiseXorTest(Int512 left, Int512 right, Int512 expected)
+	{
+		var result = left ^ right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftLeftTestData))]
+	public async Task op_ShiftLeftTest(Int512 value, int shiftAmount, Int512 expected)
+	{
+		var result = value << shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftRightTestData))]
+	public async Task op_ShiftRightTest(Int512 value, int shiftAmount, Int512 expected)
+	{
+		var result = value >> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_UnsignedShiftRightTestData))]
+	public async Task op_UnsignedShiftRightTest(Int512 value, int shiftAmount, Int512 expected)
+	{
+		var result = value >>> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+	public async Task op_EqualityTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left == right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+	public async Task op_InequalityTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left != right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+	public async Task op_LessThanTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left < right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+	public async Task op_LessThanOrEqualTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left <= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+	public async Task op_GreaterThanTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left > right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+	public async Task op_GreaterThanOrEqualTest(Int512 left, Int512 right, bool expected)
+	{
+		var result = left >= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+
+	#region INumberBase
+	[Test]
+	[MethodDataSource<DataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(Int512 value, Int512 expected)
+	{
+		Int512 result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(Int512 value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(Int512 left, Int512 right, Int512 addend, Int512 expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, Int512 expected)
+	{
+		var result = Helper.Parse<Int512>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, Int512 expected)
+	{
+		var result = Helper.Parse<Int512>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, Int512 expected)
+	{
+		var result = Helper.Parse<Int512>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, Int512 expectedValue)
+	{
+		var success = Helper.TryParse<Int512>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, Int512 expectedValue)
+	{
+		var success = Helper.TryParse<Int512>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, Int512 expectedValue)
+	{
+		var success = Helper.TryParse<Int512>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(Int512 value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+	#endregion
+	
+	#region INumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ClampTestData))]
+	public async Task ClampTest(Int512 value, Int512 min, Int512 max, Int512 expected)
+	{
+		if (min > max)
+		{
+			await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+		}
+		else
+		{
+			var result = Helper.Clamp(value, min, max);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(CopySignTestData))]
+	public async Task CopySignTest(Int512 value, Int512 sign, Int512 expected)
+	{
+		var result = Helper.CopySign(value, sign);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxTestData))]
+	public async Task MaxTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.Max(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+	public async Task MaxNumberTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MaxNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinTestData))]
+	public async Task MinTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.Min(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+	public async Task MinNumberTest(Int512 x, Int512 y, Int512 expected)
+	{
+		var result = Helper.MinNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(SignTestData))]
+	public async Task SignTest(Int512 value, int expected)
+	{
+		var result = Helper.Sign(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryNumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+	public async Task IsPow2Test(Int512 value, bool expected)
+	{
+		var result = Helper.IsPow2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(Log2TestData))]
+	public async Task Log2Test(Int512 value, Int512 expected)
+	{
+		var result = Helper.Log2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryInteger
+	[Test]
+	[MethodDataSource<DataSources>(nameof(DivRemTestData))]
+	public async Task DivRemTest(Int512 left, Int512 right, Pair<Int512> expected)
+	{
+		var result = Helper.DivRem(left, right);
+		await Assert.That((Pair<Int512>)result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(LeadingZeroCountTestData))]
+	public async Task LeadingZeroCountTest(Int512 value, Int512 expected)
+	{
+		var result = Helper.LeadingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(PopCountTestData))]
+	public async Task PopCountTest(Int512 value, Int512 expected)
+	{
+		var result = Helper.PopCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadBigEndianTestData))]
+	public async Task ReadBigEndianTest(byte[] source, bool isUnsigned, Int512 expected)
+	{
+		var result = Helper.ReadBigEndian<Int512>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadLittleEndianTestData))]
+	public async Task ReadLittleEndianTest(byte[] source, bool isUnsigned, Int512 expected)
+	{
+		var result = Helper.ReadLittleEndian<Int512>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateLeftTestData))]
+	public async Task RotateLeftTest(Int512 value, int shiftAmount, Int512 expected)
+	{
+		var result = Helper.RotateLeft(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateRightTestData))]
+	public async Task RotateRightTest(Int512 value, int shiftAmount, Int512 expected)
+	{
+		var result = Helper.RotateRight(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TrailingZeroCountTestData))]
+	public async Task TrailingZeroCountTest(Int512 value, Int512 expected)
+	{
+		var result = Helper.TrailingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetByteCountTestData))]
+	public async Task GetByteCountTest(Int512 value, int expected)
+	{
+		var result = Helper.GetByteCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetShortestBitLengthTestData))]
+	public async Task GetShortestBitLengthTest(Int512 value, int expected)
+	{
+		var result = Helper.GetShortestBitLength(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteBigEndianTestData))]
+	public async Task WriteBigEndianTest(Int512 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[Int512.Size];
+		var result = Helper.WriteBigEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteLittleEndianTestData))]
+	public async Task WriteLittleEndianTest(Int512 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[Int512.Size];
+		var result = Helper.WriteLittleEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	#endregion
+
+	#region Conversion
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(Int512 input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(Int512 input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(Int512 input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(Int512 input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(Int512 input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(Int512 input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(Int512 input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(Int512 input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(Int512 input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(Int512 input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(Int512 input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(Int512 input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(Int512 input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(Int512 input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(Int512 input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt256TestData))] public async Task ConvertToCheckedUInt256Test(Int512 input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt256TestData))] public async Task ConvertToSaturatingUInt256Test(Int512 input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt256TestData))] public async Task ConvertToTruncatingUInt256Test(Int512 input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt512TestData))] public async Task ConvertToCheckedUInt512Test(Int512 input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt512TestData))] public async Task ConvertToSaturatingUInt512Test(Int512 input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt512TestData))] public async Task ConvertToTruncatingUInt512Test(Int512 input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(Int512 input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(Int512 input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(Int512 input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(Int512 input, short expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(Int512 input, short expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(Int512 input, short expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(Int512 input, int expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(Int512 input, int expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(Int512 input, int expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(Int512 input, long expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(Int512 input, long expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(Int512 input, long expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(Int512 input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(Int512 input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(Int512 input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt256TestData))] public async Task ConvertToCheckedInt256Test(Int512 input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt256TestData))] public async Task ConvertToSaturatingInt256Test(Int512 input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt256TestData))] public async Task ConvertToTruncatingInt256Test(Int512 input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(Int512 input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(Int512 input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(Int512 input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(Int512 input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(Int512 input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(Int512 input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(Int512 input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(Int512 input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(Int512 input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(Int512 input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(Int512 input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(Int512 input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedQuadTestData))] public async Task ConvertToCheckedQuadTest(Int512 input, Quad expected) => await Assert.That(Quad.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingQuadTestData))] public async Task ConvertToSaturatingQuadTest(Int512 input, Quad expected) => await Assert.That(Quad.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingQuadTestData))] public async Task ConvertToTruncatingQuadTest(Int512 input, Quad expected) => await Assert.That(Quad.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedOctoTestData))] public async Task ConvertToCheckedOctoTest(Int512 input, Octo expected) => await Assert.That(Octo.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingOctoTestData))] public async Task ConvertToSaturatingOctoTest(Int512 input, Octo expected) => await Assert.That(Octo.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingOctoTestData))] public async Task ConvertToTruncatingOctoTest(Int512 input, Octo expected) => await Assert.That(Octo.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	#endregion
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Numerics/OctoGenericMathTests.cs b/src/MissingValues.Tests/Numerics/OctoGenericMathTests.cs
new file mode 100644
index 0000000..a006344
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/OctoGenericMathTests.cs
@@ -0,0 +1,680 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using MissingValues.Tests.Data;
+using MissingValues.Tests.Extensions;
+using static MissingValues.Tests.Data.OctoDataSources;
+
+using Float = MissingValues.Octo;
+using DataSources = MissingValues.Tests.Data.OctoDataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class OctoGenericMathTests
+{
+    #region Operators
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+    public async Task op_AdditionTest(Float left, Float right, Float expected)
+    {
+        var result = left + right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+    public async Task op_IncrementTest(Float value, Float expected)
+    {
+        var result = ++value;
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+            await Assert.That(result).IsEqualTo(value).And.IsBitwiseEquivalentTo(value);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+    public async Task op_SubtractionTest(Float left, Float right, Float expected)
+    {
+        var result = left - right;
+
+        if (Float.IsNaN(expected))
+        {
+	        await Assert.That(result).IsNaN();
+        }
+        else
+        {
+			await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+    public async Task op_DecrementTest(Float value, Float expected)
+    {
+        var result = --value;
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+            await Assert.That(result).IsEqualTo(value).And.IsBitwiseEquivalentTo(value);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+    public async Task op_MultiplyTest(Float left, Float right, Float expected)
+    {
+        var result = left * right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+    public async Task op_DivisionTest(Float left, Float right, Float expected)
+    {
+        var result = left / right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+    public async Task op_ModulusTest(Float left, Float right, Float expected)
+    {
+        var result = left % right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+    public async Task op_OnesComplementTest(Float value, Float expected)
+    {
+        var result = Helper.OnesComplement(value);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+    public async Task op_BitwiseAndTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.And(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+    public async Task op_BitwiseOrTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.Or(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+    public async Task op_BitwiseXorTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.Xor(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+    public async Task op_EqualityTest(Float left, Float right, bool expected)
+    {
+        var result = left == right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+    public async Task op_InequalityTest(Float left, Float right, bool expected)
+    {
+        var result = left != right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+    public async Task op_LessThanTest(Float left, Float right, bool expected)
+    {
+        var result = left < right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+    public async Task op_LessThanOrEqualTest(Float left, Float right, bool expected)
+    {
+        var result = left <= right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+    public async Task op_GreaterThanTest(Float left, Float right, bool expected)
+    {
+        var result = left > right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+    public async Task op_GreaterThanOrEqualTest(Float left, Float right, bool expected)
+    {
+        var result = left >= right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+
+    #region INumberBase
+    [Test]
+	[MethodDataSource<QuadDataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(Quad value, Quad expected)
+	{
+		Quad result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(Quad value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(Quad x, Quad y, Quad expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(Quad x, Quad y, Quad expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(Quad x, Quad y, Quad expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(Quad x, Quad y, Quad expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(Quad left, Quad right, Quad addend, Quad expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, Quad expected)
+	{
+		var result = Helper.Parse<Quad>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, Quad expected)
+	{
+		var result = Helper.Parse<Quad>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, Quad expected)
+	{
+		var result = Helper.Parse<Quad>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, Quad expectedValue)
+	{
+		var success = Helper.TryParse<Quad>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, Quad expectedValue)
+	{
+		var success = Helper.TryParse<Quad>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<QuadDataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, Quad expectedValue)
+	{
+		var success = Helper.TryParse<Quad>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(Float value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+    #endregion
+    
+    #region INumber
+    [Test]
+    [MethodDataSource<DataSources>(nameof(ClampTestData))]
+    public async Task ClampTest(Float value, Float min, Float max, Float expected)
+    {
+	    if (min > max)
+	    {
+		    await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+	    }
+	    else
+	    {
+		    var result = Helper.Clamp(value, min, max);
+		    await Assert.That(result).IsEqualTo(expected);
+	    }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(CopySignTestData))]
+    public async Task CopySignTest(Float value, Float sign, Float expected)
+    {
+	    var result = Helper.CopySign(value, sign);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MaxTestData))]
+    public async Task MaxTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.Max(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+    public async Task MaxNumberTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.MaxNumber(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MinTestData))]
+    public async Task MinTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.Min(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+    public async Task MinNumberTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.MinNumber(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(SignTestData))]
+    public async Task SignTest(Float value, int expected)
+    {
+	    var result = Helper.Sign(value);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region IBinaryNumber
+    [Test]
+    [MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+    public async Task IsPow2Test(Float value, bool expected)
+    {
+	    var result = Helper.IsPow2(value);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region IFloatingPoint
+    [Test]
+    [MethodDataSource<DataSources>(nameof(RoundTestData))]
+    public async Task RoundTest(Float value, int digits, MidpointRounding midpointRounding, Float expected)
+    {
+	    var result = Float.Round(value, digits, midpointRounding);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+
+    #region IFloatingPointIeee754
+    [Test]
+    [MethodDataSource<DataSources>(nameof(BitDecrementTestData))]
+    public async Task BitDecrementTest(Float value, Float expected)
+    {
+	    await Assert.That(Float.BitDecrement(value)).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(BitIncrementTestData))]
+    public async Task BitIncrementTest(Float value, Float expected)
+    {
+	    await Assert.That(Float.BitIncrement(value)).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(FusedMultiplyAddTestData))]
+    public async Task FusedMultiplyAddTest(Float left, Float right, Float addend, Float result)
+    {
+	    await Assert.That(Float.FusedMultiplyAdd(left, right, addend))
+		    .IsEqualTo(result).And
+		    .IsBitwiseEquivalentTo(result);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(Ieee754RemainderTestData))]
+    public async Task IeeeRemainderTest(Float left, Float right, Float result)
+    {
+	    if (Float.IsNaN(result))
+	    {
+		    await Assert.That(Float.Ieee754Remainder(left, right))
+			    .IsNaN();
+	    }
+	    else
+	    {
+		    await Assert.That(Float.Ieee754Remainder(left, right))
+			    .IsBitwiseEquivalentTo(result);
+	    }
+    }
+
+    [Test]
+    [MethodDataSource<DataSources>(nameof(ILogBTestData))]
+    public async Task ILogBTest(Float x, int result)
+    {
+	    await Assert.That(Float.ILogB(x)).IsEqualTo(result);
+    }
+    [Test]
+    public async Task ReciprocalEstimateTest()
+    {
+	    await Assert.That(Float.ReciprocalEstimate(Float.Two)).IsEqualTo(Float.Half);
+	    await Assert.That(Float.ReciprocalEstimate(Float.Four))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFF_D000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000), Float.Delta);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(ScaleBTestData))]
+    public async Task ScaleBTest(Float x, int n, Float result)
+    {
+	    await Assert.That(Float.ScaleB(x, n))
+		    .IsBitwiseEquivalentTo(result);
+    }
+
+    [Test]
+    public async Task SqrtTest()
+    {
+	    await Assert.That(Float.Sqrt(Float.Zero)).EqualTo(Float.Zero);
+	    await Assert.That(Float.Sqrt(Float.NegativeZero)).EqualTo(Float.NegativeZero);
+	    await Assert.That(Float.Sqrt(Float.PositiveInfinity)).EqualTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Sqrt(Float.NegativeFour)).IsNaN();
+	    await Assert.That(Float.Sqrt(Float.NaN)).IsNaN();
+	    
+	    await Assert.That(Float.Sqrt(Float.Hundred)).IsApproximately(Float.Ten, Float.Delta);
+    }
+    #endregion
+
+    #region Conversion
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(Float input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(Float input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(Float input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt256TestData))] public async Task ConvertToCheckedUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt256TestData))] public async Task ConvertToSaturatingUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt256TestData))] public async Task ConvertToTruncatingUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt512TestData))] public async Task ConvertToCheckedUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt512TestData))] public async Task ConvertToSaturatingUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt512TestData))] public async Task ConvertToTruncatingUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(Float input, short expected) => await Assert.That(short.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(Float input, short expected) => await Assert.That(short.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(Float input, short expected) => await Assert.That(short.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(Float input, int expected) => await Assert.That(int.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(Float input, int expected) => await Assert.That(int.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(Float input, int expected) => await Assert.That(int.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(Float input, long expected) => await Assert.That(long.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(Float input, long expected) => await Assert.That(long.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(Float input, long expected) => await Assert.That(long.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt256TestData))] public async Task ConvertToCheckedInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt256TestData))] public async Task ConvertToSaturatingInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt256TestData))] public async Task ConvertToTruncatingInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt512TestData))] public async Task ConvertToCheckedInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt512TestData))] public async Task ConvertToSaturatingInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt512TestData))] public async Task ConvertToTruncatingInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<QuadDataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(Quad input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<QuadDataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(Quad input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<QuadDataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(Quad input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(Float input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(Float input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(Float input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(Float input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(Float input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(Float input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(Float input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(Float input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(Float input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedQuadTestData))] public async Task ConvertToCheckedQuadTest(Float input, Quad expected) => await Assert.That(Quad.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingQuadTestData))] public async Task ConvertToSaturatingQuadTest(Float input, Quad expected) => await Assert.That(Quad.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingQuadTestData))] public async Task ConvertToTruncatingQuadTest(Float input, Quad expected) => await Assert.That(Quad.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+    #endregion
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Numerics/QuadGenericMathTests.cs b/src/MissingValues.Tests/Numerics/QuadGenericMathTests.cs
new file mode 100644
index 0000000..d1f0dff
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/QuadGenericMathTests.cs
@@ -0,0 +1,1039 @@
+using System.Globalization;
+using System.Numerics;
+using MissingValues.Tests.Extensions;
+using static MissingValues.Tests.Data.QuadDataSources;
+
+using Float = MissingValues.Quad;
+using DataSources = MissingValues.Tests.Data.QuadDataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class QuadGenericMathTests
+{
+    #region Operators
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+    public async Task op_AdditionTest(Float left, Float right, Float expected)
+    {
+        var result = left + right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+    public async Task op_IncrementTest(Float value, Float expected)
+    {
+        var result = ++value;
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+            await Assert.That(result).IsEqualTo(value).And.IsBitwiseEquivalentTo(value);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+    public async Task op_SubtractionTest(Float left, Float right, Float expected)
+    {
+        var result = left - right;
+
+        if (Float.IsNaN(expected))
+        {
+	        await Assert.That(result).IsNaN();
+        }
+        else
+        {
+			await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+    public async Task op_DecrementTest(Float value, Float expected)
+    {
+        var result = --value;
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+            await Assert.That(result).IsEqualTo(value).And.IsBitwiseEquivalentTo(value);
+        }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+    public async Task op_MultiplyTest(Float left, Float right, Float expected)
+    {
+        var result = left * right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+    public async Task op_DivisionTest(Float left, Float right, Float expected)
+    {
+        var result = left / right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+    public async Task op_ModulusTest(Float left, Float right, Float expected)
+    {
+        var result = left % right;
+
+        await Assert.That(result).IsEqualTo(expected).And.IsBitwiseEquivalentTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+    public async Task op_OnesComplementTest(Float value, Float expected)
+    {
+        var result = Helper.OnesComplement(value);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+    public async Task op_BitwiseAndTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.And(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+    public async Task op_BitwiseOrTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.Or(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+    public async Task op_BitwiseXorTest(Float left, Float right, Float expected)
+    {
+        var result = Helper.Xor(left, right);
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+    public async Task op_EqualityTest(Float left, Float right, bool expected)
+    {
+        var result = left == right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+    public async Task op_InequalityTest(Float left, Float right, bool expected)
+    {
+        var result = left != right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+    public async Task op_LessThanTest(Float left, Float right, bool expected)
+    {
+        var result = left < right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+    public async Task op_LessThanOrEqualTest(Float left, Float right, bool expected)
+    {
+        var result = left <= right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+    public async Task op_GreaterThanTest(Float left, Float right, bool expected)
+    {
+        var result = left > right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+    public async Task op_GreaterThanOrEqualTest(Float left, Float right, bool expected)
+    {
+        var result = left >= right;
+
+        await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region INumberBase
+    [Test]
+	[MethodDataSource<DataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(Float value, Float expected)
+	{
+		Float result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(Float value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(Float value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(Float value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(Float value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(Float value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(Float value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(Float value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(Float value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(Float value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(Float value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(Float value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(Float value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(Float value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(Float value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(Float value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(Float value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(Float value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(Float x, Float y, Float expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(Float x, Float y, Float expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(Float x, Float y, Float expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(Float x, Float y, Float expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(Float left, Float right, Float addend, Float expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, Float expected)
+	{
+		var result = Helper.Parse<Float>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, Float expected)
+	{
+		var result = Helper.Parse<Float>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, Float expected)
+	{
+		var result = Helper.Parse<Float>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, Float expectedValue)
+	{
+		var success = Helper.TryParse<Float>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, Float expectedValue)
+	{
+		var success = Helper.TryParse<Float>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, Float expectedValue)
+	{
+		var success = Helper.TryParse<Float>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(Float value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+    #endregion
+    
+    #region INumber
+    [Test]
+    [MethodDataSource<DataSources>(nameof(ClampTestData))]
+    public async Task ClampTest(Float value, Float min, Float max, Float expected)
+    {
+	    if (min > max)
+	    {
+		    await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+	    }
+	    else
+	    {
+		    var result = Helper.Clamp(value, min, max);
+		    await Assert.That(result).IsEqualTo(expected);
+	    }
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(CopySignTestData))]
+    public async Task CopySignTest(Float value, Float sign, Float expected)
+    {
+	    var result = Helper.CopySign(value, sign);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MaxTestData))]
+    public async Task MaxTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.Max(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+    public async Task MaxNumberTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.MaxNumber(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MinTestData))]
+    public async Task MinTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.Min(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+    public async Task MinNumberTest(Float x, Float y, Float expected)
+    {
+	    var result = Helper.MinNumber(x, y);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(SignTestData))]
+    public async Task SignTest(Float value, int expected)
+    {
+	    var result = Helper.Sign(value);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region IBinaryNumber
+    [Test]
+    [MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+    public async Task IsPow2Test(Float value, bool expected)
+    {
+	    var result = Helper.IsPow2(value);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region IFloatingPoint
+    [Test]
+    [MethodDataSource<DataSources>(nameof(RoundTestData))]
+    public async Task RoundTest(Float value, int digits, MidpointRounding midpointRounding, Float expected)
+    {
+	    var result = Float.Round(value, digits, midpointRounding);
+	    await Assert.That(result).IsEqualTo(expected);
+    }
+    #endregion
+    
+    #region IFloatingPointIeee754
+    [Test]
+    public async Task AcosTest()
+    {
+	    await Assert.That(Float.Acos(Float.NaN)).IsNaN();
+	    await Assert.That(Float.Acos(Float.Two)).IsNaN();
+	    await Assert.That(Float.Acos(Float.NegativeTwo)).IsNaN();
+	    await Assert.That(Float.Acos(Float.Half))
+		    .IsApproximately(Float.Pi / Float.Three, Float.Delta);
+	    await Assert.That(Float.Acos(Float.One))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Acos(Float.NegativeOne))
+		    .IsApproximately(Float.Pi, Float.Delta);
+    }
+    [Test]
+    public async Task AcoshTest()
+    {
+	    await Assert.That(Float.Acosh(Float.Two))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFF_5124_2719_8043, 0x49BE_684B_D018_8D53), Float.Delta);
+	    await Assert.That(Float.Acosh(Float.Half)).IsNaN();
+	    await Assert.That(Float.Acosh(Float.Zero)).IsNaN();
+	    await Assert.That(Float.Acosh(Float.NegativeOne)).IsNaN();
+    }
+    [Test]
+    public async Task AsinTest()
+    {
+	    await Assert.That(Float.Asin(Float.Half))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFE_0C15_2382_D736, 0x5846_5BB3_2E0F_567B), Float.Delta)
+		    .And.IsApproximately(Float.Pi / Float.Six, Float.Delta);
+	    await Assert.That(Float.Asin(Float.Two)).IsNaN();
+	    await Assert.That(Float.Asin(Float.One))
+		    .IsApproximately(Float.Pi / Float.Two, Float.Delta);
+	    await Assert.That(Float.Asin(Float.NegativeOne))
+		    .IsApproximately(-Float.Pi / Float.Two, Float.Delta);
+    }
+    [Test]
+    public async Task AsinhTest()
+    {
+	    await Assert.That(Float.Asinh(Float.Two))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFF_7192_1831_3D08, 0x72F8_E831_837F_0E95), Float.Delta);
+	    await Assert.That(Float.Asinh(Float.Zero))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Asinh(Values.CreateFloat<Float>(0xBFFF_8000_0000_0000, 0x0000_0000_0000_0000)))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFF_31DC_0090_B63D, 0x8682_7E4B_AAAD_1909), Float.Delta);
+    }
+    [Test]
+    public async Task AtanTest()
+    {
+	    await Assert.That(Float.Atan(Float.Half))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Float.Delta);
+	    await Assert.That(Float.Atan(Float.Zero))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Atan(Float.PositiveInfinity))
+		    .IsApproximately(Float.Pi / Float.Two, Float.Delta);
+	    await Assert.That(Float.Atan(Float.Two))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFF_1B6E_192E_BBE4, 0x3F5A_7D44_566B_01A8), Float.Delta);
+    }
+    [Test]
+    public async Task Atan2Test()
+    {
+	    await Assert.That(Float.Atan2(Float.Zero, Float.Two))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Atan2(Float.Zero, Float.Zero))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Atan2(Float.Zero, Float.NegativeTwo))
+		    .IsApproximately(Float.Pi, Float.Delta);
+	    await Assert.That(Float.Atan2(Float.One, Float.Two))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Float.Delta);
+	    await Assert.That(Float.Atan2(Float.NegativeOne, Float.Two))
+		    .IsApproximately(Values.CreateFloat<Float>(0xBFFD_DAC6_7056_1BB4, 0xF1DE_7924_87B0_F0F3), Float.Delta);
+	    await Assert.That(Float.Atan2(Float.One, Float.NegativeTwo))
+		    .IsApproximately(Values.CreateFloat<Float>(0x4000_56C6_E739_7F5A, 0xE130_A2BB_E272_574C), Float.Delta);
+    }
+    [Test]
+    public async Task AtanhTest()
+    {
+	    await Assert.That(Float.Atanh(Float.Two))
+		    .IsNaN();
+	    await Assert.That(Float.Atanh(Float.NegativeFour))
+		    .IsNaN();
+	    await Assert.That(Float.Atanh(Float.Zero))
+		    .IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(Float.Atanh(Float.Half))
+		    .IsApproximately(Values.CreateFloat<Float>(0x3FFE_193E_A7AA_D030, 0xA976_BA8D_B53A_D6E3), Float.Delta);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(BitDecrementTestData))]
+    public async Task BitDecrementTest(Float value, Float expected)
+    {
+	    await Assert.That(Float.BitDecrement(value)).IsEqualTo(expected);
+    }
+    [Test]
+    [MethodDataSource<DataSources>(nameof(BitIncrementTestData))]
+    public async Task BitIncrementTest(Float value, Float expected)
+    {
+	    await Assert.That(Float.BitIncrement(value)).IsEqualTo(expected);
+    }
+    [Test]
+    public async Task CbrtTest()
+    {
+	    await Assert.That(Float.Cbrt(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000)))
+		    .IsEqualTo(Float.Four);
+	    await Assert.That(Float.Cbrt(Float.Zero))
+		    .IsEqualTo(Float.Zero);
+	    await Assert.That(Float.Cbrt(Float.NegativeZero))
+		    .IsEqualTo(Float.NegativeZero);
+	    await Assert.That(Float.Cbrt(Float.NegativeFour))
+		    .IsApproximately(Values.CreateFloat<Float>(0xBFFF_965F_EA53_D6E3, 0xC82B_0599_9AB4_3DC5), Float.Delta);
+	    await Assert.That(Float.Cbrt(Float.NaN)).IsNaN();
+    }
+    [Test]
+	public async Task CosTest()
+	{
+		await Assert.That(Float.Cos(Float.Zero))
+			.IsApproximately(Float.One, Float.Delta);
+		await Assert.That(Float.Cos(Float.Pi / Float.Two))
+			.IsApproximately(Float.Zero, Float.Delta);
+		await Assert.That(Float.Cos(Float.Pi))
+			.IsApproximately(Float.NegativeOne, Float.Delta);
+		await Assert.That(Float.Cos(Float.Pi * Float.Two))
+			.IsApproximately(Float.One, Float.Delta);
+		await Assert.That(Float.Cos(Float.NaN))
+			.IsNaN();
+		await Assert.That(Float.Cos(Float.PositiveInfinity))
+			.IsNaN();
+		await Assert.That(Float.Cos(Float.NegativeInfinity))
+			.IsNaN();
+	}
+	[Test]
+	public async Task CoshTest()
+	{
+		await Assert.That(Float.Cosh(Float.Zero))
+			.IsBitwiseEquivalentTo(Float.One);
+		await Assert.That(Float.Cosh(Float.Two))
+			.IsApproximately(Values.CreateFloat<Float>(0x4000_E18F_A0DF_2D9B, 0xC293_27F7_1777_4D0C), Float.Delta);
+		await Assert.That(Float.Cosh(Float.Five))
+			.IsApproximately(Values.CreateFloat<Float>(0x4005_28D6_FCBE_FF3A, 0x9C65_3333_916C_7D52), Float.Delta);
+		await Assert.That(Float.Cosh(Float.NegativeFive))
+			.IsApproximately(Values.CreateFloat<Float>(0x4005_28D6_FCBE_FF3A, 0x9C65_3333_916C_7D52), Float.Delta);
+	}
+	[Test]
+	public async Task ExpTest()
+	{
+		await Assert.That(Float.Exp(Float.Two))
+			.IsApproximately(Values.CreateFloat<Float>(0x4001_D8E6_4B8D_4DDA, 0xDCC3_3A3B_A206_B68B), Float.Delta);
+		await Assert.That(Float.Exp(Float.NegativeHalf))
+			.IsApproximately(Values.CreateFloat<Float>(0x3FFE_368B_2FC6_F960, 0x9FE7_ACEB_46AA_619C), Float.Delta);
+		await Assert.That(Float.Exp(Values.CreateFloat<Float>(0x400C_7700_0000_0000, 0x0000_0000_0000_0000)))
+			.IsEqualTo(Float.PositiveInfinity);
+		await Assert.That(Float.Exp(Values.CreateFloat<Float>(0xC00C_7700_0000_0000, 0x0000_0000_0000_0000)))
+			.IsEqualTo(Float.Zero);
+		await Assert.That(Float.Exp(Float.Zero))
+			.IsEqualTo(Float.One);
+		await Assert.That(Float.Exp(Float.PositiveInfinity))
+			.IsEqualTo(Float.PositiveInfinity);
+		await Assert.That(Float.Exp(Float.NaN))
+			.IsNaN();
+		await Assert.That(Float.Exp(Float.NegativeInfinity))
+			.IsEqualTo(Float.Zero);
+	}
+	[Test]
+	public async Task ExpM1Test()
+	{
+		await Assert.That(Float.ExpM1(Float.Two))
+			.IsApproximately(Float.Exp(Float.Two) - Float.One, Float.Delta);;
+		await Assert.That(Float.ExpM1(Float.NegativeHalf))
+			.IsApproximately(Float.Exp(Float.NegativeHalf) - Float.One, Float.Delta);
+	}
+	[Test]
+	public async Task Exp10Test()
+	{
+		await Assert.That(Float.Exp10(Float.Two))
+			.IsEqualTo(Float.Hundred);
+		await Assert.That(Float.Exp10(Float.Zero))
+			.IsEqualTo(Float.One);
+		await Assert.That(Float.Exp10(Float.PositiveInfinity))
+			.IsEqualTo(Float.PositiveInfinity);
+		await Assert.That(Float.Exp10(Float.NaN))
+			.IsNaN();
+		await Assert.That(Float.Exp10(Float.NegativeInfinity))
+			.IsEqualTo(Float.Zero);
+	}
+	[Test]
+	public async Task Exp2Test()
+	{
+		await Assert.That(Float.Exp2(Float.Two))
+			.IsEqualTo(Float.Four);
+		await Assert.That(Float.Exp2(Float.Zero))
+			.IsEqualTo(Float.One);
+		await Assert.That(Float.Exp2(Float.PositiveInfinity))
+			.IsEqualTo(Float.PositiveInfinity);
+		await Assert.That(Float.Exp2(Float.NaN))
+			.IsNaN();
+		await Assert.That(Float.Exp2(Float.NegativeInfinity))
+			.IsEqualTo(Float.Zero);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(FusedMultiplyAddTestData))]
+	public async Task FusedMultiplyAddTest(Float left, Float right, Float addend, Float result)
+	{
+		await Assert.That(Float.FusedMultiplyAdd(left, right, addend))
+			.IsEqualTo(result).And
+			.IsBitwiseEquivalentTo(result);
+	}
+	[Test]
+	public async Task HypotTest()
+	{
+		await Assert.That(Float.Hypot(Float.Hundred, Float.Ten))
+			.IsApproximately(Values.CreateFloat<Float>(0x4005_91FE_B9F2_BF46, 0xC3A7_08A3_1212_49E7), Float.Delta);
+		await Assert.That(Float.Hypot(Float.PositiveInfinity, Float.NegativeInfinity))
+			.IsBitwiseEquivalentTo(Float.PositiveInfinity);
+		await Assert.That(Float.Hypot(Float.NaN, Float.NaN))
+			.IsNaN();
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(Ieee754RemainderTestData))]
+	public async Task IeeeRemainderTest(Float left, Float right, Float result)
+	{
+		if (Float.IsNaN(result))
+		{
+			await Assert.That(Float.Ieee754Remainder(left, right))
+				.IsNaN();
+		}
+		else
+		{
+			await Assert.That(Float.Ieee754Remainder(left, right))
+				.IsBitwiseEquivalentTo(result);
+		}
+	}
+
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ILogBTestData))]
+	public async Task ILogBTest(Float x, int result)
+	{
+		await Assert.That(Float.ILogB(x)).IsEqualTo(result);
+	}
+	[Test]
+	public async Task LogTest()
+	{
+		await Assert.That(Float.Log(Float.Hundred))
+			.IsApproximately(Values.CreateFloat<Float>(0x4001_26BB_1BBB_5551, 0x582D_D4AD_AC57_05A6), Float.Delta);
+		await Assert.That(Float.Log(Float.One))
+			.IsEqualTo(Float.Zero);
+		await Assert.That(Float.Log(Float.Zero))
+			.IsEqualTo(Float.NegativeInfinity);
+		await Assert.That(Float.Log(Float.NegativeFive))
+			.IsNaN();
+	}
+	[Test]
+	public async Task LogP1Test()
+	{
+		await Assert.That(Float.LogP1(Float.One))
+			.IsBitwiseEquivalentTo(Float.Log(Float.Two))
+			.And.IsApproximately(Values.CreateFloat<Float>(0x3FFE_62E4_2FEF_A39E, 0xF357_93C7_6730_07E6), Float.Delta);
+		await Assert.That(Float.LogP1(Float.Zero))
+			.IsBitwiseEquivalentTo(Float.Zero);
+		await Assert.That(Float.LogP1(Float.NegativeOne))
+			.IsBitwiseEquivalentTo(Float.NegativeInfinity);
+		await Assert.That(Float.LogP1(Float.NegativeFive))
+			.IsNaN();
+	}
+    [Test]
+    public async Task Log2Test()
+    {
+	    await Assert.That(Helper.Log2(Float.Four)).IsApproximately(Float.Two, Float.Delta);
+	    await Assert.That(Helper.Log2(Float.One)).IsEqualTo(Float.Zero);
+	    await Assert.That(Helper.Log2(Float.Zero)).IsEqualTo(Float.NegativeInfinity);
+	    await Assert.That(Helper.Log2(Float.NegativeFive)).IsNaN();
+    }
+    [Test]
+    public async Task Log10Test()
+    {
+	    await Assert.That(Float.Log10(Float.Thousand))
+		    .IsApproximately(Float.Three, Float.Delta);
+	    await Assert.That(Float.Log10(Float.One))
+		    .IsEqualTo(Float.Zero);
+	    await Assert.That(Float.Log10(Float.Zero))
+		    .IsEqualTo(Float.NegativeInfinity);
+	    await Assert.That(Float.Log10(Float.NegativeFive))
+		    .IsNaN();
+    }
+    
+    [Test]
+	public async Task PowTest()
+	{
+	    await Assert.That(Float.Pow(Float.Three, Float.Ten))
+	        .IsApproximately(Values.CreateFloat<Float>(0x400E_CD52_0000_0000, 0x0000_0000_0000_0000), Float.Delta);
+	    await Assert.That(Float.Pow(Float.Two, Float.NegativeFour))
+	        .IsApproximately(Values.CreateFloat<Float>(0x3FFB_0000_0000_0000, 0x0000_0000_0000_0000), Float.Delta);
+	
+	    Float anything = 8, oddInt = 7, nonInt = 7.5d, greaterThanOne = Float.GreaterThanOneSmallest, lessThanOne = Float.LessThanOneLargest;
+	
+	    await Assert.That(Float.Pow(anything, Float.Zero)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(anything, Float.One)).IsBitwiseEquivalentTo(anything);
+	    await Assert.That(Float.Pow(anything, Float.NaN)).IsNaN();
+	    await Assert.That(Float.Pow(Float.One, Float.NaN)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(Float.NaN, anything)).IsNaN();
+	    await Assert.That(Float.Pow(greaterThanOne, Float.PositiveInfinity)).IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Pow(greaterThanOne, Float.NegativeInfinity)).IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Pow(lessThanOne, Float.PositiveInfinity)).IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Pow(lessThanOne, Float.NegativeInfinity)).IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Pow(Float.One, Float.PositiveInfinity)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(Float.One, Float.NegativeInfinity)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(Float.NegativeOne, Float.PositiveInfinity)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(Float.NegativeOne, Float.NegativeInfinity)).IsBitwiseEquivalentTo(Float.One);
+	    await Assert.That(Float.Pow(Float.Zero, anything)).IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Pow(Float.NegativeZero, anything)).IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Pow(Float.Zero, -anything)).IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Pow(Float.NegativeZero, -anything)).IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    
+	    await Assert.That(Float.Pow(Float.NegativeZero, oddInt))
+	        .IsBitwiseEquivalentTo(-(Float.Pow(Float.Zero, oddInt)));
+	    await Assert.That(Float.Pow(Float.PositiveInfinity, anything)).IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Pow(Float.PositiveInfinity, -anything)).IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Pow(Float.NegativeInfinity, anything))
+	        .IsBitwiseEquivalentTo(Float.Pow(Float.NegativeZero, -anything));
+	    await Assert.That(Float.Pow(-anything, oddInt))
+	        .IsBitwiseEquivalentTo(Float.Pow(Float.NegativeOne, oddInt) * Float.Pow(+anything, oddInt));
+	    await Assert.That(Float.Pow(-anything, nonInt)).IsNaN();
+	}
+	[Test]
+	public async Task ReciprocalEstimateTest()
+	{
+		await Assert.That(Float.ReciprocalEstimate(Float.Two)).IsEqualTo(Float.Half);
+		await Assert.That(Float.ReciprocalEstimate(Float.Three))
+			.IsApproximately(Values.CreateFloat<Float>(0x3FFD_5555_5555_5555, 0x5555_165E_5289_24A5), Float.Delta);
+		await Assert.That(Float.ReciprocalEstimate(Float.Four))
+			.IsApproximately(Values.CreateFloat<Float>(0x3FFD_0000_0000_0000, 0x0000_0000_0000_0000), Float.Delta);
+	}
+	[Test]
+	public async Task RootNTest()
+	{
+		await Assert.That(Float.RootN(Values.CreateFloat<Float>(0x4005_4400_0000_0000, 0x0000_0000_0000_0000), 4))
+			.IsBitwiseEquivalentTo(Float.Three);
+		await Assert.That(Float.RootN(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000), 3))
+			.IsEqualTo(Float.Four)
+			.And.IsEqualTo(Float.Cbrt(Values.CreateFloat<Float>(0x4005_0000_0000_0000, 0x0000_0000_0000_0000)));
+		await Assert.That(Float.RootN(Float.Hundred, 2))
+			.IsBitwiseEquivalentTo(Float.Ten)
+			.And.IsEqualTo(Float.Sqrt(Float.Hundred));
+		await Assert.That(Float.RootN(Float.Zero, 2))
+			.IsBitwiseEquivalentTo(Float.Zero);
+		await Assert.That(Float.RootN(Float.NegativeZero, 2))
+			.IsBitwiseEquivalentTo(Float.Zero);
+		await Assert.That(Float.RootN(Float.PositiveInfinity, 2))
+			.IsBitwiseEquivalentTo(Float.PositiveInfinity);
+		await Assert.That(Float.RootN(Float.NegativeFour, 2))
+			.IsNaN();
+		await Assert.That(Float.RootN(Float.NaN, 2))
+			.IsNaN();
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ScaleBTestData))]
+	public async Task ScaleBTest(Float x, int n, Float result)
+	{
+	    await Assert.That(Float.ScaleB(x, n))
+		    .IsBitwiseEquivalentTo(result);
+	}
+	[Test]
+	public async Task SinTest()
+	{
+	    await Assert.That(Float.Sin(Float.NaN))
+		    .IsNaN();
+	    await Assert.That(Float.Sin(Float.PositiveInfinity))
+		    .IsNaN();
+	    await Assert.That(Float.Sin(Float.NegativeInfinity))
+		    .IsNaN();
+	}
+	[Test]
+	public async Task SinCosTest()
+	{
+	    Float sin, cos;
+	    (sin, cos) = Float.SinCos(Float.Zero);
+	    await Assert.That(sin).IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(cos).IsApproximately(Float.One, Float.Delta);
+	
+	    (sin, cos) = Float.SinCos(Float.Pi);
+	    await Assert.That(sin).IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(cos).IsApproximately(Float.NegativeOne, Float.Delta);
+	
+	    (sin, cos) = Float.SinCos(Float.Pi / Float.Two);
+	    await Assert.That(sin).IsApproximately(Float.One, Float.Delta);
+	    await Assert.That(cos).IsApproximately(Float.Zero, Float.Delta);
+	
+	    (sin, cos) = Float.SinCos(Float.Pi * Float.Two);
+	    await Assert.That(sin).IsApproximately(Float.Zero, Float.Delta);
+	    await Assert.That(cos).IsApproximately(Float.One, Float.Delta);
+	}
+	[Test]
+	public async Task SinhTest()
+	{
+	    await Assert.That(Float.Sinh(Float.Two))
+	        .IsApproximately(Values.CreateFloat<Float>(0x4000_D03C_F63B_6E19, 0xF6F3_4C80_2C96_2009), Float.Delta);
+	    await Assert.That(Float.Sinh(Float.Zero))
+		    .IsBitwiseEquivalentTo(Float.Zero);
+	}
+	[Test]
+	public async Task SqrtTest()
+	{
+	    await Assert.That(Float.Sqrt(Float.Ten))
+	        .IsApproximately(Values.CreateFloat<Float>(0x4000_94C5_83AD_A5B5, 0x2920_4A2B_C830_CD9C), Float.Delta);
+	    await Assert.That(Float.Sqrt(Float.Hundred))
+		    .IsApproximately(Float.Ten, Float.Delta);
+	    await Assert.That(Float.Sqrt(Float.Zero))
+		    .IsBitwiseEquivalentTo(Float.Zero);
+	    await Assert.That(Float.Sqrt(-Float.NegativeZero))
+		    .IsBitwiseEquivalentTo(-Float.NegativeZero);
+	    await Assert.That(Float.Sqrt(Float.PositiveInfinity))
+		    .IsBitwiseEquivalentTo(Float.PositiveInfinity);
+	    await Assert.That(Float.Sqrt(Float.NegativeFour))
+		    .IsNaN();
+	    await Assert.That(Float.Sqrt(Float.NaN))
+		    .IsNaN();
+	}
+	[Test]
+	public async Task TanTest()
+	{
+	    await Assert.That(Float.Tan(Float.NaN))
+		    .IsNaN();
+	    await Assert.That(Float.Tan(Float.PositiveInfinity))
+		    .IsNaN();
+	    await Assert.That(Float.Tan(Float.NegativeInfinity))
+		    .IsNaN();
+	}
+	[Test]
+	public async Task TanhTest()
+	{
+	    await Assert.That(Float.Tanh(Float.Two))
+	        .IsApproximately(Values.CreateFloat<Float>(0x3FFE_ED95_05E1_BC3D, 0x3D33_C432_FC3E_8256), Float.Delta);
+	    await Assert.That(Float.Tanh(Float.NaN))
+		    .IsNaN();
+	    await Assert.That(Float.Tanh(Float.Zero))
+		    .IsBitwiseEquivalentTo(Float.Zero);
+	}
+    #endregion
+
+    #region Conversion
+    [Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(Float input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(Float input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(Float input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(Float input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(Float input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(Float input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(Float input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt256TestData))] public async Task ConvertToCheckedUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt256TestData))] public async Task ConvertToSaturatingUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt256TestData))] public async Task ConvertToTruncatingUInt256Test(Float input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt512TestData))] public async Task ConvertToCheckedUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt512TestData))] public async Task ConvertToSaturatingUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt512TestData))] public async Task ConvertToTruncatingUInt512Test(Float input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(Float input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(Float input, short expected) => await Assert.That(short.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(Float input, short expected) => await Assert.That(short.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(Float input, short expected) => await Assert.That(short.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(Float input, int expected) => await Assert.That(int.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(Float input, int expected) => await Assert.That(int.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(Float input, int expected) => await Assert.That(int.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(Float input, long expected) => await Assert.That(long.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(Float input, long expected) => await Assert.That(long.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(Float input, long expected) => await Assert.That(long.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(Float input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt256TestData))] public async Task ConvertToCheckedInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt256TestData))] public async Task ConvertToSaturatingInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt256TestData))] public async Task ConvertToTruncatingInt256Test(Float input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt512TestData))] public async Task ConvertToCheckedInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt512TestData))] public async Task ConvertToSaturatingInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt512TestData))] public async Task ConvertToTruncatingInt512Test(Float input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(Float input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(Float input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(Float input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(Float input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(Float input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(Float input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(Float input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(Float input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(Float input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(Float input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(Float input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(Float input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedOctoTestData))] public async Task ConvertToCheckedOctoTest(Float input, Octo expected) => await Assert.That(Octo.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingOctoTestData))] public async Task ConvertToSaturatingOctoTest(Float input, Octo expected) => await Assert.That(Octo.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingOctoTestData))] public async Task ConvertToTruncatingOctoTest(Float input, Octo expected) => await Assert.That(Octo.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, Float expected) => await Assert.That(Float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, Float expected) => await Assert.That(Float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, Float expected) => await Assert.That(Float.CreateTruncating(input)).IsEqualTo(expected);
+    #endregion
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Numerics/UInt256GenericMathTests.cs b/src/MissingValues.Tests/Numerics/UInt256GenericMathTests.cs
new file mode 100644
index 0000000..317d12c
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/UInt256GenericMathTests.cs
@@ -0,0 +1,806 @@
+using MissingValues.Tests.Data;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using static MissingValues.Tests.Data.UInt256DataSources;
+
+using DataSources = MissingValues.Tests.Data.UInt256DataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class UInt256GenericMathTests
+{
+	#region Operators
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+	public async Task op_AdditionTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left + right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedAdditionTestData))]
+	public async Task op_CheckedAdditionTest(UInt256 left, UInt256 right, UInt256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left + right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left + right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+	public async Task op_IncrementTest(UInt256 value, UInt256 expected)
+	{
+		var result = ++value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedIncrementTestData))]
+	public async Task op_CheckedIncrementTest(UInt256 value, UInt256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(++value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(++value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+	public async Task op_SubtractionTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left - right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedSubtractionTestData))]
+	public async Task op_CheckedSubtractionTest(UInt256 left, UInt256 right, UInt256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left - right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left - right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+	public async Task op_DecrementTest(UInt256 value, UInt256 expected)
+	{
+		var result = --value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedDecrementTestData))]
+	public async Task op_CheckedDecrementTest(UInt256 value, UInt256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(--value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(--value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+	public async Task op_MultiplyTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left * right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedMultiplyTestData))]
+	public async Task op_CheckedMultiplyTest(UInt256 left, UInt256 right, UInt256 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left * right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left * right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+	public async Task op_DivisionTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		if (right == UInt256.Zero)
+		{
+			await Assert.That(() => left / right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left / right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+	public async Task op_ModulusTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		if (right == UInt256.Zero)
+		{
+			await Assert.That(() => left % right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left % right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+	public async Task op_OnesComplementTest(UInt256 value, UInt256 expected)
+	{
+		var result = ~value;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+	public async Task op_BitwiseAndTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left & right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+	public async Task op_BitwiseOrTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left | right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+	public async Task op_BitwiseXorTest(UInt256 left, UInt256 right, UInt256 expected)
+	{
+		var result = left ^ right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftLeftTestData))]
+	public async Task op_ShiftLeftTest(UInt256 value, int shiftAmount, UInt256 expected)
+	{
+		var result = value << shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftRightTestData))]
+	public async Task op_ShiftRightTest(UInt256 value, int shiftAmount, UInt256 expected)
+	{
+		var result = value >> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_UnsignedShiftRightTestData))]
+	public async Task op_UnsignedShiftRightTest(UInt256 value, int shiftAmount, UInt256 expected)
+	{
+		var result = value >>> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+	public async Task op_EqualityTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left == right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+	public async Task op_InequalityTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left != right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+	public async Task op_LessThanTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left < right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+	public async Task op_LessThanOrEqualTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left <= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+	public async Task op_GreaterThanTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left > right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+	public async Task op_GreaterThanOrEqualTest(UInt256 left, UInt256 right, bool expected)
+	{
+		var result = left >= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+
+	#region INumberBase
+	[Test]
+	[MethodDataSource<DataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(UInt256 value, UInt256 expected)
+	{
+		UInt256 result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(UInt256 value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(UInt256 left, UInt256 right, UInt256 addend, UInt256 expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, UInt256 expected)
+	{
+		var result = Helper.Parse<UInt256>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, UInt256 expected)
+	{
+		var result = Helper.Parse<UInt256>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, UInt256 expected)
+	{
+		var result = Helper.Parse<UInt256>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, UInt256 expectedValue)
+	{
+		var success = Helper.TryParse<UInt256>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, UInt256 expectedValue)
+	{
+		var success = Helper.TryParse<UInt256>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, UInt256 expectedValue)
+	{
+		var success = Helper.TryParse<UInt256>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(UInt256 value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+	#endregion
+	
+	#region INumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ClampTestData))]
+	public async Task ClampTest(UInt256 value, UInt256 min, UInt256 max, UInt256 expected)
+	{
+		if (min > max)
+		{
+			await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+		}
+		else
+		{
+			var result = Helper.Clamp(value, min, max);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(CopySignTestData))]
+	public async Task CopySignTest(UInt256 value, UInt256 sign, UInt256 expected)
+	{
+		var result = Helper.CopySign(value, sign);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxTestData))]
+	public async Task MaxTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.Max(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+	public async Task MaxNumberTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MaxNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinTestData))]
+	public async Task MinTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.Min(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+	public async Task MinNumberTest(UInt256 x, UInt256 y, UInt256 expected)
+	{
+		var result = Helper.MinNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(SignTestData))]
+	public async Task SignTest(UInt256 value, int expected)
+	{
+		var result = Helper.Sign(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryNumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+	public async Task IsPow2Test(UInt256 value, bool expected)
+	{
+		var result = Helper.IsPow2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(Log2TestData))]
+	public async Task Log2Test(UInt256 value, UInt256 expected)
+	{
+		var result = Helper.Log2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryInteger
+	[Test]
+	[MethodDataSource<DataSources>(nameof(DivRemTestData))]
+	public async Task DivRemTest(UInt256 left, UInt256 right, Pair<UInt256> expected)
+	{
+		var result = Helper.DivRem(left, right);
+		await Assert.That((Pair<UInt256>)result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(LeadingZeroCountTestData))]
+	public async Task LeadingZeroCountTest(UInt256 value, UInt256 expected)
+	{
+		var result = Helper.LeadingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(PopCountTestData))]
+	public async Task PopCountTest(UInt256 value, UInt256 expected)
+	{
+		var result = Helper.PopCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadBigEndianTestData))]
+	public async Task ReadBigEndianTest(byte[] source, bool isUnsigned, UInt256 expected)
+	{
+		var result = Helper.ReadBigEndian<UInt256>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadLittleEndianTestData))]
+	public async Task ReadLittleEndianTest(byte[] source, bool isUnsigned, UInt256 expected)
+	{
+		var result = Helper.ReadLittleEndian<UInt256>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateLeftTestData))]
+	public async Task RotateLeftTest(UInt256 value, int shiftAmount, UInt256 expected)
+	{
+		var result = Helper.RotateLeft(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateRightTestData))]
+	public async Task RotateRightTest(UInt256 value, int shiftAmount, UInt256 expected)
+	{
+		var result = Helper.RotateRight(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TrailingZeroCountTestData))]
+	public async Task TrailingZeroCountTest(UInt256 value, UInt256 expected)
+	{
+		var result = Helper.TrailingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetByteCountTestData))]
+	public async Task GetByteCountTest(UInt256 value, int expected)
+	{
+		var result = Helper.GetByteCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetShortestBitLengthTestData))]
+	public async Task GetShortestBitLengthTest(UInt256 value, int expected)
+	{
+		var result = Helper.GetShortestBitLength(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteBigEndianTestData))]
+	public async Task WriteBigEndianTest(UInt256 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[UInt256.Size];
+		var result = Helper.WriteBigEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteLittleEndianTestData))]
+	public async Task WriteLittleEndianTest(UInt256 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[UInt256.Size];
+		var result = Helper.WriteLittleEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	#endregion
+
+	#region Conversion
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(UInt256 input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(UInt256 input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(UInt256 input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(UInt256 input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(UInt256 input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(UInt256 input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(UInt256 input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(UInt256 input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(UInt256 input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(UInt256 input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(UInt256 input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(UInt256 input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(UInt256 input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(UInt256 input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(UInt256 input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt512TestData))] public async Task ConvertToCheckedUInt512Test(UInt256 input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt512TestData))] public async Task ConvertToSaturatingUInt512Test(UInt256 input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt512TestData))] public async Task ConvertToTruncatingUInt512Test(UInt256 input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(UInt256 input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(UInt256 input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(UInt256 input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(UInt256 input, short expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(UInt256 input, short expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(UInt256 input, short expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(UInt256 input, int expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(UInt256 input, int expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(UInt256 input, int expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(UInt256 input, long expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(UInt256 input, long expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(UInt256 input, long expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(UInt256 input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(UInt256 input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(UInt256 input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt256TestData))] public async Task ConvertToCheckedInt256Test(UInt256 input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt256TestData))] public async Task ConvertToSaturatingInt256Test(UInt256 input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt256TestData))] public async Task ConvertToTruncatingInt256Test(UInt256 input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt512TestData))] public async Task ConvertToCheckedInt512Test(UInt256 input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt512TestData))] public async Task ConvertToSaturatingInt512Test(UInt256 input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt512TestData))] public async Task ConvertToTruncatingInt512Test(UInt256 input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(UInt256 input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(UInt256 input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(UInt256 input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(UInt256 input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(UInt256 input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(UInt256 input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(UInt256 input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(UInt256 input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(UInt256 input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(UInt256 input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(UInt256 input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(UInt256 input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedQuadTestData))] public async Task ConvertToCheckedQuadTest(UInt256 input, Quad expected) => await Assert.That(Quad.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingQuadTestData))] public async Task ConvertToSaturatingQuadTest(UInt256 input, Quad expected) => await Assert.That(Quad.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingQuadTestData))] public async Task ConvertToTruncatingQuadTest(UInt256 input, Quad expected) => await Assert.That(Quad.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedOctoTestData))] public async Task ConvertToCheckedOctoTest(UInt256 input, Octo expected) => await Assert.That(Octo.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingOctoTestData))] public async Task ConvertToSaturatingOctoTest(UInt256 input, Octo expected) => await Assert.That(Octo.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingOctoTestData))] public async Task ConvertToTruncatingOctoTest(UInt256 input, Octo expected) => await Assert.That(Octo.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+	#endregion
+}
diff --git a/src/MissingValues.Tests/Numerics/UInt512GenericMathTests.cs b/src/MissingValues.Tests/Numerics/UInt512GenericMathTests.cs
new file mode 100644
index 0000000..a05f66b
--- /dev/null
+++ b/src/MissingValues.Tests/Numerics/UInt512GenericMathTests.cs
@@ -0,0 +1,805 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using static MissingValues.Tests.Data.UInt512DataSources;
+
+using DataSources = MissingValues.Tests.Data.UInt512DataSources;
+
+namespace MissingValues.Tests.Numerics;
+
+public class UInt512GenericMathTests
+{
+	#region Operators
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_AdditionTestData))]
+	public async Task op_AdditionTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left + right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedAdditionTestData))]
+	public async Task op_CheckedAdditionTest(UInt512 left, UInt512 right, UInt512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left + right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left + right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_IncrementTestData))]
+	public async Task op_IncrementTest(UInt512 value, UInt512 expected)
+	{
+		var result = ++value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedIncrementTestData))]
+	public async Task op_CheckedIncrementTest(UInt512 value, UInt512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(++value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(++value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_SubtractionTestData))]
+	public async Task op_SubtractionTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left - right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedSubtractionTestData))]
+	public async Task op_CheckedSubtractionTest(UInt512 left, UInt512 right, UInt512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left - right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left - right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DecrementTestData))]
+	public async Task op_DecrementTest(UInt512 value, UInt512 expected)
+	{
+		var result = --value;
+
+		await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedDecrementTestData))]
+	public async Task op_CheckedDecrementTest(UInt512 value, UInt512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(--value)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(--value);
+			await Assert.That(result).IsEqualTo(expected).And.IsEqualTo(value);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_MultiplyTestData))]
+	public async Task op_MultiplyTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left * right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_CheckedMultiplyTestData))]
+	public async Task op_CheckedMultiplyTest(UInt512 left, UInt512 right, UInt512 expected, bool overflows)
+	{
+		if (overflows)
+		{
+			await Assert.That(() => checked(left * right)).Throws<OverflowException>();
+		}
+		else
+		{
+			var result = checked(left * right);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_DivisionTestData))]
+	public async Task op_DivisionTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		if (right == UInt512.Zero)
+		{
+			await Assert.That(() => left / right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left / right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ModulusTestData))]
+	public async Task op_ModulusTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		if (right == UInt512.Zero)
+		{
+			await Assert.That(() => left % right).Throws<DivideByZeroException>();
+		}
+		else
+		{
+			var result = left % right;
+
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_OnesComplementTestData))]
+	public async Task op_OnesComplementTest(UInt512 value, UInt512 expected)
+	{
+		var result = ~value;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseAndTestData))]
+	public async Task op_BitwiseAndTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left & right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseOrTestData))]
+	public async Task op_BitwiseOrTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left | right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_BitwiseXorTestData))]
+	public async Task op_BitwiseXorTest(UInt512 left, UInt512 right, UInt512 expected)
+	{
+		var result = left ^ right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftLeftTestData))]
+	public async Task op_ShiftLeftTest(UInt512 value, int shiftAmount, UInt512 expected)
+	{
+		var result = value << shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_ShiftRightTestData))]
+	public async Task op_ShiftRightTest(UInt512 value, int shiftAmount, UInt512 expected)
+	{
+		var result = value >> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_UnsignedShiftRightTestData))]
+	public async Task op_UnsignedShiftRightTest(UInt512 value, int shiftAmount, UInt512 expected)
+	{
+		var result = value >>> shiftAmount;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_EqualityTestData))]
+	public async Task op_EqualityTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left == right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_InequalityTestData))]
+	public async Task op_InequalityTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left != right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanTestData))]
+	public async Task op_LessThanTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left < right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_LessThanOrEqualTestData))]
+	public async Task op_LessThanOrEqualTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left <= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanTestData))]
+	public async Task op_GreaterThanTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left > right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(op_GreaterThanOrEqualTestData))]
+	public async Task op_GreaterThanOrEqualTest(UInt512 left, UInt512 right, bool expected)
+	{
+		var result = left >= right;
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+
+	#region INumberBase
+	[Test]
+	[MethodDataSource<DataSources>(nameof(AbsTestData))]
+	public async Task AbsTest(UInt512 value, UInt512 expected)
+	{
+		UInt512 result = Helper.Abs(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsCanonicalTestData))]
+	public async Task IsCanonicalTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsCanonical(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsComplexNumberTestData))]
+	public async Task IsComplexNumberTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsComplexNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsEvenIntegerTestData))]
+	public async Task IsEvenIntegerTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsEvenInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsFiniteTestData))]
+	public async Task IsFiniteTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsFinite(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsImaginaryNumberTestData))]
+	public async Task IsImaginaryNumberTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsImaginaryNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsInfinityTestData))]
+	public async Task IsInfinityTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsIntegerTestData))]
+	public async Task IsIntegerTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNaNTestData))]
+	public async Task IsNaNTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsNaN(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeTestData))]
+	public async Task IsNegativeTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsNegative(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNegativeInfinityTestData))]
+	public async Task IsNegativeInfinityTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsNegativeInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsNormalTestData))]
+	public async Task IsNormalTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsNormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsOddIntegerTestData))]
+	public async Task IsOddIntegerTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsOddInteger(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveTestData))]
+	public async Task IsPositiveTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsPositive(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPositiveInfinityTestData))]
+	public async Task IsPositiveInfinityTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsPositiveInfinity(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsRealNumberTestData))]
+	public async Task IsRealNumberTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsRealNumber(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsSubnormalTestData))]
+	public async Task IsSubnormalTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsSubnormal(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsZeroTestData))]
+	public async Task IsZeroTest(UInt512 value, bool expected)
+	{
+		bool result = Helper.IsZero(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeTestData))]
+	public async Task MaxMagnitudeTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MaxMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxMagnitudeNumberTestData))]
+	public async Task MaxMagnitudeNumberTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MaxMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeTestData))]
+	public async Task MinMagnitudeTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MinMagnitude(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinMagnitudeNumberTestData))]
+	public async Task MinMagnitudeNumberTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MinMagnitudeNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MultiplyAddEstimateTestData))]
+	public async Task MultiplyAddEstimateTest(UInt512 left, UInt512 right, UInt512 addend, UInt512 expected)
+	{
+		var result = Helper.MultiplyAddEstimate(left, right, addend);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseTestData))]
+	public async Task ParseTest(string s, NumberStyles style, IFormatProvider? provider, UInt512 expected)
+	{
+		var result = Helper.Parse<UInt512>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseSpanTestData))]
+	public async Task ParseTest(char[] s, NumberStyles style, IFormatProvider? provider, UInt512 expected)
+	{
+		var result = Helper.Parse<UInt512>(s, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ParseUtf8TestData))]
+	public async Task ParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, UInt512 expected)
+	{
+		var result = Helper.Parse<UInt512>(utf8Text, style, provider);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseTestData))]
+	public async Task TryParseTest(string s, NumberStyles style, IFormatProvider? provider, bool expected, UInt512 expectedValue)
+	{
+		var success = Helper.TryParse<UInt512>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseSpanTestData))]
+	public async Task TryParseTest(char[] s, NumberStyles style, IFormatProvider? provider, bool expected, UInt512 expectedValue)
+	{
+		var success = Helper.TryParse<UInt512>(s, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TryParseUtf8TestData))]
+	public async Task TryParseTest(byte[] utf8Text, NumberStyles style, IFormatProvider? provider, bool expected, UInt512 expectedValue)
+	{
+		var success = Helper.TryParse<UInt512>(utf8Text, style, provider, out var result);
+		using (Assert.Multiple())
+		{
+			await Assert.That(success).IsEqualTo(expected);
+			await Assert.That(result).IsEqualTo(expectedValue);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ToStringTestData))]
+	public async Task ToStringTest(UInt512 value, string fmt, IFormatProvider? provider, string expected)
+	{
+		await Assert.That(value.ToString(fmt, provider)).EqualTo(expected);
+	}
+	#endregion
+	
+	#region INumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ClampTestData))]
+	public async Task ClampTest(UInt512 value, UInt512 min, UInt512 max, UInt512 expected)
+	{
+		if (min > max)
+		{
+			await Assert.That(() => Helper.Clamp(value, min, max)).Throws<ArgumentException>();
+		}
+		else
+		{
+			var result = Helper.Clamp(value, min, max);
+			await Assert.That(result).IsEqualTo(expected);
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(CopySignTestData))]
+	public async Task CopySignTest(UInt512 value, UInt512 sign, UInt512 expected)
+	{
+		var result = Helper.CopySign(value, sign);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxTestData))]
+	public async Task MaxTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.Max(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MaxNumberTestData))]
+	public async Task MaxNumberTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MaxNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinTestData))]
+	public async Task MinTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.Min(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(MinNumberTestData))]
+	public async Task MinNumberTest(UInt512 x, UInt512 y, UInt512 expected)
+	{
+		var result = Helper.MinNumber(x, y);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(SignTestData))]
+	public async Task SignTest(UInt512 value, int expected)
+	{
+		var result = Helper.Sign(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryNumber
+	[Test]
+	[MethodDataSource<DataSources>(nameof(IsPow2TestData))]
+	public async Task IsPow2Test(UInt512 value, bool expected)
+	{
+		var result = Helper.IsPow2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(Log2TestData))]
+	public async Task Log2Test(UInt512 value, UInt512 expected)
+	{
+		var result = Helper.Log2(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	#endregion
+	
+	#region IBinaryInteger
+	[Test]
+	[MethodDataSource<DataSources>(nameof(DivRemTestData))]
+	public async Task DivRemTest(UInt512 left, UInt512 right, Pair<UInt512> expected)
+	{
+		var result = Helper.DivRem(left, right);
+		await Assert.That((Pair<UInt512>)result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(LeadingZeroCountTestData))]
+	public async Task LeadingZeroCountTest(UInt512 value, UInt512 expected)
+	{
+		var result = Helper.LeadingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(PopCountTestData))]
+	public async Task PopCountTest(UInt512 value, UInt512 expected)
+	{
+		var result = Helper.PopCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadBigEndianTestData))]
+	public async Task ReadBigEndianTest(byte[] source, bool isUnsigned, UInt512 expected)
+	{
+		var result = Helper.ReadBigEndian<UInt512>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(ReadLittleEndianTestData))]
+	public async Task ReadLittleEndianTest(byte[] source, bool isUnsigned, UInt512 expected)
+	{
+		var result = Helper.ReadLittleEndian<UInt512>(source, isUnsigned);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateLeftTestData))]
+	public async Task RotateLeftTest(UInt512 value, int shiftAmount, UInt512 expected)
+	{
+		var result = Helper.RotateLeft(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(RotateRightTestData))]
+	public async Task RotateRightTest(UInt512 value, int shiftAmount, UInt512 expected)
+	{
+		var result = Helper.RotateRight(value, shiftAmount);
+
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(TrailingZeroCountTestData))]
+	public async Task TrailingZeroCountTest(UInt512 value, UInt512 expected)
+	{
+		var result = Helper.TrailingZeroCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetByteCountTestData))]
+	public async Task GetByteCountTest(UInt512 value, int expected)
+	{
+		var result = Helper.GetByteCount(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(GetShortestBitLengthTestData))]
+	public async Task GetShortestBitLengthTest(UInt512 value, int expected)
+	{
+		var result = Helper.GetShortestBitLength(value);
+		await Assert.That(result).IsEqualTo(expected);
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteBigEndianTestData))]
+	public async Task WriteBigEndianTest(UInt512 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[UInt512.Size];
+		var result = Helper.WriteBigEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	[Test]
+	[MethodDataSource<DataSources>(nameof(WriteLittleEndianTestData))]
+	public async Task WriteLittleEndianTest(UInt512 value, byte[] expectedDestination, int expected)
+	{
+		byte[] buffer = new byte[UInt512.Size];
+		var result = Helper.WriteLittleEndian(value, buffer);
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(result).IsEqualTo(expected);
+			await Assert.That(buffer.Length).IsEqualTo(expectedDestination.Length);
+			for (int i = 0; i < buffer.Length; i++)
+			{
+				await Assert.That(buffer[i]).IsEqualTo(expectedDestination[i]);
+			}
+		}
+	}
+	#endregion
+
+	#region Conversion
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedByteTestData))] public async Task ConvertToCheckedByteTest(UInt512 input, byte expected) => await Assert.That(byte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingByteTestData))] public async Task ConvertToSaturatingByteTest(UInt512 input, byte expected) => await Assert.That(byte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingByteTestData))] public async Task ConvertToTruncatingByteTest(UInt512 input, byte expected) => await Assert.That(byte.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt16TestData))] public async Task ConvertToCheckedUInt16Test(UInt512 input, ushort expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt16TestData))] public async Task ConvertToSaturatingUInt16Test(UInt512 input, ushort expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt16TestData))] public async Task ConvertToTruncatingUInt16Test(UInt512 input, ushort expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt32TestData))] public async Task ConvertToCheckedUInt32Test(UInt512 input, uint expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt32TestData))] public async Task ConvertToSaturatingUInt32Test(UInt512 input, uint expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt32TestData))] public async Task ConvertToTruncatingUInt32Test(UInt512 input, uint expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt64TestData))] public async Task ConvertToCheckedUInt64Test(UInt512 input, ulong expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt64TestData))] public async Task ConvertToSaturatingUInt64Test(UInt512 input, ulong expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt64TestData))] public async Task ConvertToTruncatingUInt64Test(UInt512 input, ulong expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt128TestData))] public async Task ConvertToCheckedUInt128Test(UInt512 input, UInt128 expected) => await Assert.That(UInt128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt128TestData))] public async Task ConvertToSaturatingUInt128Test(UInt512 input, UInt128 expected) => await Assert.That(UInt128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt128TestData))] public async Task ConvertToTruncatingUInt128Test(UInt512 input, UInt128 expected) => await Assert.That(UInt128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedUInt256TestData))] public async Task ConvertToCheckedUInt256Test(UInt512 input, UInt256 expected) => await Assert.That(UInt256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingUInt256TestData))] public async Task ConvertToSaturatingUInt256Test(UInt512 input, UInt256 expected) => await Assert.That(UInt256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingUInt256TestData))] public async Task ConvertToTruncatingUInt256Test(UInt512 input, UInt256 expected) => await Assert.That(UInt256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSByteTestData))] public async Task ConvertToCheckedSByteTest(UInt512 input, sbyte expected) => await Assert.That(sbyte.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSByteTestData))] public async Task ConvertToSaturatingSByteTest(UInt512 input, sbyte expected) => await Assert.That(sbyte.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSByteTestData))] public async Task ConvertToTruncatingByteTest(UInt512 input, sbyte expected) => await Assert.That(sbyte.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt16TestData))] public async Task ConvertToCheckedInt16Test(UInt512 input, short expected) => await Assert.That(ushort.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt16TestData))] public async Task ConvertToSaturatingInt16Test(UInt512 input, short expected) => await Assert.That(ushort.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt16TestData))] public async Task ConvertToTruncatingInt16Test(UInt512 input, short expected) => await Assert.That(ushort.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt32TestData))] public async Task ConvertToCheckedInt32Test(UInt512 input, int expected) => await Assert.That(uint.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt32TestData))] public async Task ConvertToSaturatingInt32Test(UInt512 input, int expected) => await Assert.That(uint.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt32TestData))] public async Task ConvertToTruncatingInt32Test(UInt512 input, int expected) => await Assert.That(uint.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt64TestData))] public async Task ConvertToCheckedInt64Test(UInt512 input, long expected) => await Assert.That(ulong.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt64TestData))] public async Task ConvertToSaturatingInt64Test(UInt512 input, long expected) => await Assert.That(ulong.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt64TestData))] public async Task ConvertToTruncatingInt64Test(UInt512 input, long expected) => await Assert.That(ulong.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt128TestData))] public async Task ConvertToCheckedInt128Test(UInt512 input, Int128 expected) => await Assert.That(Int128.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt128TestData))] public async Task ConvertToSaturatingInt128Test(UInt512 input, Int128 expected) => await Assert.That(Int128.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt128TestData))] public async Task ConvertToTruncatingInt128Test(UInt512 input, Int128 expected) => await Assert.That(Int128.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt256TestData))] public async Task ConvertToCheckedInt256Test(UInt512 input, Int256 expected) => await Assert.That(Int256.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt256TestData))] public async Task ConvertToSaturatingInt256Test(UInt512 input, Int256 expected) => await Assert.That(Int256.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt256TestData))] public async Task ConvertToTruncatingInt256Test(UInt512 input, Int256 expected) => await Assert.That(Int256.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedInt512TestData))] public async Task ConvertToCheckedInt512Test(UInt512 input, Int512 expected) => await Assert.That(Int512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingInt512TestData))] public async Task ConvertToSaturatingInt512Test(UInt512 input, Int512 expected) => await Assert.That(Int512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingInt512TestData))] public async Task ConvertToTruncatingInt512Test(UInt512 input, Int512 expected) => await Assert.That(Int512.CreateTruncating(input)).IsEqualTo(expected);
+
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedBigIntegerTestData))] public async Task ConvertToCheckedBigIntegerTest(UInt512 input, BigInteger expected) => await Assert.That(BigInteger.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingBigIntegerTestData))] public async Task ConvertToSaturatingBigIntegerTest(UInt512 input, BigInteger expected) => await Assert.That(BigInteger.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingBigIntegerTestData))] public async Task ConvertToTruncatingBigIntegerTest(UInt512 input, BigInteger expected) => await Assert.That(BigInteger.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedHalfTestData))] public async Task ConvertToCheckedHalfTest(UInt512 input, Half expected) => await Assert.That(Half.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingHalfTestData))] public async Task ConvertToSaturatingHalfTest(UInt512 input, Half expected) => await Assert.That(Half.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingHalfTestData))] public async Task ConvertToTruncatingHalfTest(UInt512 input, Half expected) => await Assert.That(Half.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedSingleTestData))] public async Task ConvertToCheckedSingleTest(UInt512 input, float expected) => await Assert.That(float.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingSingleTestData))] public async Task ConvertToSaturatingSingleTest(UInt512 input, float expected) => await Assert.That(float.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingSingleTestData))] public async Task ConvertToTruncatingSingleTest(UInt512 input, float expected) => await Assert.That(float.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedDoubleTestData))] public async Task ConvertToCheckedDoubleTest(UInt512 input, double expected) => await Assert.That(double.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingDoubleTestData))] public async Task ConvertToSaturatingDoubleTest(UInt512 input, double expected) => await Assert.That(double.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingDoubleTestData))] public async Task ConvertToTruncatingDoubleTest(UInt512 input, double expected) => await Assert.That(double.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedQuadTestData))] public async Task ConvertToCheckedQuadTest(UInt512 input, Quad expected) => await Assert.That(Quad.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingQuadTestData))] public async Task ConvertToSaturatingQuadTest(UInt512 input, Quad expected) => await Assert.That(Quad.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingQuadTestData))] public async Task ConvertToTruncatingQuadTest(UInt512 input, Quad expected) => await Assert.That(Quad.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToCheckedOctoTestData))] public async Task ConvertToCheckedOctoTest(UInt512 input, Octo expected) => await Assert.That(Octo.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToSaturatingOctoTestData))] public async Task ConvertToSaturatingOctoTest(UInt512 input, Octo expected) => await Assert.That(Octo.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertToTruncatingOctoTestData))] public async Task ConvertToTruncatingOctoTest(UInt512 input, Octo expected) => await Assert.That(Octo.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedByteTestData))] public async Task ConvertFromCheckedByteTest(byte input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingByteTestData))] public async Task ConvertFromSaturatingByteTest(byte input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingByteTestData))] public async Task ConvertFromTruncatingByteTest(byte input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt16TestData))] public async Task ConvertFromCheckedUInt16Test(ushort input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt16TestData))] public async Task ConvertFromSaturatingUInt16Test(ushort input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt16TestData))] public async Task ConvertFromTruncatingUInt16Test(ushort input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt32TestData))] public async Task ConvertFromCheckedUInt32Test(uint input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt32TestData))] public async Task ConvertFromSaturatingUInt32Test(uint input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt32TestData))] public async Task ConvertFromTruncatingUInt32Test(uint input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt64TestData))] public async Task ConvertFromCheckedUInt64Test(ulong input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt64TestData))] public async Task ConvertFromSaturatingUInt64Test(ulong input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt64TestData))] public async Task ConvertFromTruncatingUInt64Test(ulong input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedUInt128TestData))] public async Task ConvertFromCheckedUInt128Test(UInt128 input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingUInt128TestData))] public async Task ConvertFromSaturatingUInt128Test(UInt128 input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingUInt128TestData))] public async Task ConvertFromTruncatingUInt128Test(UInt128 input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSByteTestData))] public async Task ConvertFromCheckedSByteTest(sbyte input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSByteTestData))] public async Task ConvertFromSaturatingSByteTest(sbyte input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSByteTestData))] public async Task ConvertFromTruncatingSByteTest(sbyte input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt16TestData))] public async Task ConvertFromCheckedInt16Test(short input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt16TestData))] public async Task ConvertFromSaturatingInt16Test(short input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt16TestData))] public async Task ConvertFromTruncatingInt16Test(short input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt32TestData))] public async Task ConvertFromCheckedInt32Test(int input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt32TestData))] public async Task ConvertFromSaturatingInt32Test(int input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt32TestData))] public async Task ConvertFromTruncatingInt32Test(int input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt64TestData))] public async Task ConvertFromCheckedInt64Test(long input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt64TestData))] public async Task ConvertFromSaturatingInt64Test(long input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt64TestData))] public async Task ConvertFromTruncatingInt64Test(long input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedInt128TestData))] public async Task ConvertFromCheckedInt128Test(Int128 input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingInt128TestData))] public async Task ConvertFromSaturatingInt128Test(Int128 input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingInt128TestData))] public async Task ConvertFromTruncatingInt128Test(Int128 input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedBigIntegerTestData))] public async Task ConvertFromCheckedBigIntegerTest(BigInteger input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingBigIntegerTestData))] public async Task ConvertFromSaturatingBigIntegerTest(BigInteger input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingBigIntegerTestData))] public async Task ConvertFromTruncatingBigIntegerTest(BigInteger input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedHalfTestData))] public async Task ConvertFromCheckedHalfTest(Half input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingHalfTestData))] public async Task ConvertFromSaturatingHalfTest(Half input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingHalfTestData))] public async Task ConvertFromTruncatingHalfTest(Half input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedSingleTestData))] public async Task ConvertFromCheckedSingleTest(float input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingSingleTestData))] public async Task ConvertFromSaturatingSingleTest(float input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingSingleTestData))] public async Task ConvertFromTruncatingSingleTest(float input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromCheckedDoubleTestData))] public async Task ConvertFromCheckedDoubleTest(double input, UInt512 expected) => await Assert.That(UInt512.CreateChecked(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromSaturatingDoubleTestData))] public async Task ConvertFromSaturatingDoubleTest(double input, UInt512 expected) => await Assert.That(UInt512.CreateSaturating(input)).IsEqualTo(expected);
+	[Test, MethodDataSource<DataSources>(nameof(ConvertFromTruncatingDoubleTestData))] public async Task ConvertFromTruncatingDoubleTest(double input, UInt512 expected) => await Assert.That(UInt512.CreateTruncating(input)).IsEqualTo(expected);
+	#endregion
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Pair.cs b/src/MissingValues.Tests/Pair.cs
new file mode 100644
index 0000000..3d8307e
--- /dev/null
+++ b/src/MissingValues.Tests/Pair.cs
@@ -0,0 +1,9 @@
+namespace MissingValues.Tests;
+
+public record struct Pair<T>(T First, T Second)
+{
+    public static implicit operator Pair<T>((T, T) p)
+    {
+        return new Pair<T>(p.Item1, p.Item2);
+    }
+}
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Usings.cs b/src/MissingValues.Tests/Usings.cs
deleted file mode 100644
index 261e222..0000000
--- a/src/MissingValues.Tests/Usings.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-global using Xunit;
-global using FluentAssertions;
-global using MissingValues;
-global using MissingValues.Tests.Helpers;
\ No newline at end of file
diff --git a/src/MissingValues.Tests/Values.cs b/src/MissingValues.Tests/Values.cs
new file mode 100644
index 0000000..956196d
--- /dev/null
+++ b/src/MissingValues.Tests/Values.cs
@@ -0,0 +1,33 @@
+using System.Text;
+
+namespace MissingValues.Tests;
+
+public static class Values
+{
+	public static TFloat CreateFloat<TFloat>(params ReadOnlySpan<ulong> bits)
+	{
+		if (typeof(TFloat) == typeof(Quad) && bits.Length == 2)
+		{
+			return (TFloat)(object)Quad.UInt128BitsToQuad(new UInt128(bits[0], bits[1]));
+		}
+		if (typeof(TFloat) == typeof(Octo) && bits.Length == 4)
+		{
+			return (TFloat)(object)Octo.UInt256BitsToOcto(new UInt256(bits[0], bits[1], bits[2], bits[3]));
+		}
+
+		throw new InvalidOperationException($"{typeof(TFloat)} does not match the bits({bits.Length}): {StringifyBits(bits)}");
+
+		static string StringifyBits(ReadOnlySpan<ulong> bits)
+		{
+			StringBuilder sb = new StringBuilder();
+
+			sb.Append($"0x{bits[0]:X16}");
+			for (int i = 1; i < bits.Length; i++)
+			{
+				sb.Append($"_{bits[i]:X16}");
+			}
+
+			return sb.ToString();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/MissingValues.sln b/src/MissingValues.sln
index 8edf16b..64e0f8d 100644
--- a/src/MissingValues.sln
+++ b/src/MissingValues.sln
@@ -5,10 +5,10 @@ VisualStudioVersion = 17.6.33723.286
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MissingValues", "MissingValues\MissingValues.csproj", "{2C6A1B89-E93F-4DC1-B5B2-9E062CEACF18}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MissingValues.Tests", "MissingValues.Tests\MissingValues.Tests.csproj", "{F370A95B-2718-4C84-BC74-1CA1EF7B2F3B}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MissingValues.Benchmarks", "MissingValues.Benchmarks\MissingValues.Benchmarks.csproj", "{FE774888-7645-4298-B3F3-751111ACAA36}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MissingValues.Tests", "MissingValues.Tests\MissingValues.Tests.csproj", "{EA33A386-2C6C-4541-93CB-4FC40905DE67}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -19,14 +19,14 @@ Global
 		{2C6A1B89-E93F-4DC1-B5B2-9E062CEACF18}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2C6A1B89-E93F-4DC1-B5B2-9E062CEACF18}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2C6A1B89-E93F-4DC1-B5B2-9E062CEACF18}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F370A95B-2718-4C84-BC74-1CA1EF7B2F3B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F370A95B-2718-4C84-BC74-1CA1EF7B2F3B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F370A95B-2718-4C84-BC74-1CA1EF7B2F3B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F370A95B-2718-4C84-BC74-1CA1EF7B2F3B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{FE774888-7645-4298-B3F3-751111ACAA36}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FE774888-7645-4298-B3F3-751111ACAA36}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FE774888-7645-4298-B3F3-751111ACAA36}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FE774888-7645-4298-B3F3-751111ACAA36}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EA33A386-2C6C-4541-93CB-4FC40905DE67}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EA33A386-2C6C-4541-93CB-4FC40905DE67}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EA33A386-2C6C-4541-93CB-4FC40905DE67}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EA33A386-2C6C-4541-93CB-4FC40905DE67}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE